Merge branch 'avalonia' into 'develop'

Enhance image processing performance and flexibility by introducing atomic...

See merge request MaddoScientisto/Catalog!2

.github/copilot-instructions.md

@@ -0,0 +1,90 @@
+# Copilot Instructions
+
+## Build & Test Commands
+
+```powershell
+# Build
+dotnet build Catalog.sln
+
+# Run all tests
+dotnet test MaddoShared.Tests
+
+# Run a single test
+dotnet test MaddoShared.Tests --filter "FullyQualifiedName~MethodName"
+
+# Benchmarks (modes: quick | all | parallel | chunks | sizes | stress)
+.\run-benchmarks.ps1 quick
+
+# Publish release build (self-contained Windows EXE)
+dotnet publish "imagecatalog\ImageCatalog 2.csproj" -c Release -r win-x64 --self-contained
+```
+
+## Architecture
+
+This is a WinForms/WPF image cataloging application targeting .NET 10.0-windows.
+
+### Projects
+
+| Project | Purpose |
+|---------|---------|
+| **imagecatalog** | Main desktop application — WinForms (default), WPF (`--wpf`), or Avalonia (`--avalonia`) |
+| **MaddoShared** | Shared image processing library (the core) |
+| **MaddoShared.Tests** | Unit tests for MaddoShared |
+| **MaddoShared.Benchmarks** | BenchmarkDotNet performance benchmarks |
+| **WPFCatalog** | Alternate WPF UI (secondary) |
+| **ImageCatalogCS / ImageCatalogParallel** | Legacy/experimental variants |
+| **CatalogLib / CatalogLibVb / CatalogVbLib** | Legacy VB.NET libraries |
+
+The main app selects its UI at startup via command-line flag:
+- *(default)* — WinForms (`MainForm`)
+- `--wpf` — WPF with MahApps.Metro (`MainWindow`)
+- `--avalonia` — Avalonia with Fluent theme (`AvaloniaMainWindow`)
+
+All three UIs bind to the same `DataModel`. Dialog events (`SelectSourceFolderRequested`, etc.) are subscribed in each window's code-behind. `DataModel.UiInvoker` must be set by the active UI to enable cross-thread UI updates (Avalonia sets this to `Dispatcher.UIThread.Invoke`; WPF uses `Application.Current.Dispatcher`).
+
+### Core Flow
+
+1. User configures paths/settings in the UI (`DataModel.cs` — MVVM ViewModel)
+2. `ProcessImagesCommand` triggers `ImageCreationService`
+3. `ImageCreationService` processes files in parallel chunks, with configurable concurrency and batch size (GC flush between chunks)
+4. Each file is handled by an `IImageCreator` implementation (GDI+ or ImageSharp)
+5. Output: resized/watermarked/overlaid images written to a destination folder hierarchy
+
+### Key Abstractions (MaddoShared)
+
+- **`IImageCreator`** — single async method to process one image; two implementations: `ImageCreatorGDI` (System.Drawing) and `ImageCreatorSharp` (SixLabors.ImageSharp)
+- **`ImageCreationService`** — parallel orchestrator; uses `AsyncEnumerator` with chunking; loads logo once, clones per thread for thread safety
+- **`ImageState`** — per-file processing context (input path, EXIF orientation, thumbnail sizes, overlays, logo, rotation)
+- **`PicSettings`** — 50+ property configuration model (dimensions, fonts, colors, JPEG quality, watermark, logo positioning, `ImageCreatorProvider` selector)
+- **`FileHelperSharp`** — recursive file enumeration with folder-per-N-files mapping and counter formatting
+
+### Implementation Selection
+
+`PicSettings.ImageCreatorProvider` switches between `"Sharp"` (SixLabors.ImageSharp) and `"Alternate"` (GDI+) at runtime.
+
+## Conventions
+
+### C# Style
+- File-scoped namespaces everywhere: `namespace MaddoShared;`
+- Nullable reference types enabled (`<Nullable>enable</Nullable>`)
+- Implicit usings enabled
+- `ConfigureAwait(false)` on all `await` calls in library code
+
+### Dependency Injection
+- Constructor injection throughout; loggers typed as `ILogger<T>`
+- Main app wires services in `Program.cs` via `IServiceCollection`
+
+### Testing
+- MSTest with `[TestClass]` / `[TestMethod]`
+- FluentAssertions for assertions
+- Moq for mocking
+- Factory helper pattern in tests: `CreateService(Action<Config> configure = null)` methods for flexible test setup
+
+### Async / Parallelism
+- All image I/O is `async Task`
+- `ImageCreationService` uses configurable `MaxDegreeOfParallelism` and `ChunkSize`; explicit `GC.Collect()` between chunks to manage memory under batch load
+
+### Versioning & CI
+- Semantic versioning via **GitVersion** (mode: `ContinuousDelivery`, current base: `3.2.0`)
+- GitLab CI pipeline: builds → single-file self-contained EXE → GitLab Release
+- Private NuGet packages scoped to `AIFotoONLUS.*` prefix, routed to the GitLab package registry (see `NuGet.Config`)

.gitignore

@@ -255,3 +255,4 @@ paket-files/
 # JetBrains Rider
 .idea/
 *.sln.iml
+.vscode/settings.json

Catalog.Communication/Abstractions/IRaceUploadCommunicationClient.cs

@@ -0,0 +1,40 @@
+using Catalog.Communication.Models;
+
+namespace Catalog.Communication.Abstractions;
+
+public interface IRaceUploadCommunicationClient
+{
+    Task<RawEndpointResponse> LoginAdminAsync(AdminLoginRequest request, CancellationToken cancellationToken = default);
+
+    Task<RawEndpointResponse> LogoutAdminAsync(CancellationToken cancellationToken = default);
+
+    Task<UploadImageResponse?> UploadRaceImageAsync(RaceImageUploadRequest request, CancellationToken cancellationToken = default);
+
+    Task<UploadImageResponse?> RemoveRaceImageAsync(RaceImageRemoveRequest request, CancellationToken cancellationToken = default);
+
+    Task<UploadFileResponse?> UploadRaceFileAsync(RaceFileUploadRequest request, CancellationToken cancellationToken = default);
+
+    Task<RawEndpointResponse> SaveRaceAsync(RaceSaveRequest request, CancellationToken cancellationToken = default);
+
+    Task<RawEndpointResponse> CreateRacePointsAsync(long raceId, CancellationToken cancellationToken = default);
+
+    Task<RawEndpointResponse> IndexRacePointAsync(long pointId, CancellationToken cancellationToken = default);
+
+    Task<RawEndpointResponse> GetRaceDetailAsync(long raceId, CancellationToken cancellationToken = default);
+
+    Task<RawEndpointResponse> UploadFileToReceiverAsync(ReceiveFileUploadRequest request, CancellationToken cancellationToken = default);
+
+    Task<RawEndpointResponse> ExecuteGaraCommandAsync(IReadOnlyDictionary<string, string?> formFields, CancellationToken cancellationToken = default);
+
+    Task<RawEndpointResponse> ExecuteAdminPhotoCommandAsync(AdminPhotoEndpoint endpoint, IReadOnlyDictionary<string, string?> formFields, CancellationToken cancellationToken = default);
+
+    Task<RawEndpointResponse> ExecutePublicLogonAsync(IReadOnlyDictionary<string, string?> formFields, CancellationToken cancellationToken = default);
+
+    Task<RawEndpointResponse> ExecuteUsersAsync(HttpMethod method, IReadOnlyDictionary<string, string?>? formFields = null, CancellationToken cancellationToken = default);
+
+    Task<RawEndpointResponse> ExecuteFoto2Async(HttpMethod method, IReadOnlyDictionary<string, string?>? formFields = null, CancellationToken cancellationToken = default);
+
+    Task<MediaFileResponse> DownloadThumbnailAsync(string filename, long? idFoto = null, CancellationToken cancellationToken = default);
+
+    Task<MediaFileResponse> DownloadOriginalAsync(string filename, long? idFoto = null, CancellationToken cancellationToken = default);
+}

Catalog.Communication/Catalog.Communication.csproj

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <OutputType>Library</OutputType>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.3" />
+    <PackageReference Include="Microsoft.Extensions.Http" Version="10.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.3" />
+    <PackageReference Include="Microsoft.Extensions.Options" Version="10.0.3" />
+  </ItemGroup>
+
+</Project>

Catalog.Communication/CatalogCommunicationOptions.cs

@@ -0,0 +1,16 @@
+namespace Catalog.Communication;
+
+public sealed class CatalogCommunicationOptions
+{
+    public required Uri BaseUri { get; set; }
+
+    public string AdminPageBasePath { get; set; } = "admin/pg";
+
+    public string ReceiveFilePath { get; set; } = "ReceiveFile.abl";
+
+    public TimeSpan RequestTimeout { get; set; } = TimeSpan.FromSeconds(30);
+
+    public int RetryCount { get; set; } = 2;
+
+    public TimeSpan RetryBaseDelay { get; set; } = TimeSpan.FromMilliseconds(250);
+}

Catalog.Communication/DependencyInjection/CatalogCommunicationServiceCollectionExtensions.cs

@@ -0,0 +1,57 @@
+using System.Net;
+using Catalog.Communication.Abstractions;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.Extensions.Options;
+
+namespace Catalog.Communication.DependencyInjection;
+
+public static class CatalogCommunicationServiceCollectionExtensions
+{
+    public static IServiceCollection AddCatalogCommunication(this IServiceCollection services, Action<CatalogCommunicationOptions> configure)
+    {
+        ArgumentNullException.ThrowIfNull(services);
+        ArgumentNullException.ThrowIfNull(configure);
+
+        services
+            .AddOptions<CatalogCommunicationOptions>()
+            .Configure(configure)
+            .Validate(o => o.BaseUri is not null, "CatalogCommunicationOptions.BaseUri is required.")
+            .Validate(o => !string.IsNullOrWhiteSpace(o.AdminPageBasePath), "AdminPageBasePath is required.")
+            .Validate(o => !string.IsNullOrWhiteSpace(o.ReceiveFilePath), "ReceiveFilePath is required.")
+            .Validate(o => o.RequestTimeout > TimeSpan.Zero, "RequestTimeout must be greater than zero.")
+            .Validate(o => o.RetryCount >= 0 && o.RetryCount <= 10, "RetryCount must be between 0 and 10.")
+            .Validate(o => o.RetryBaseDelay > TimeSpan.Zero, "RetryBaseDelay must be greater than zero.");
+
+        services.TryAddSingleton<CookieContainer>();
+
+        // Create the HttpClient only when the communication client is requested.
+        // This avoids constructing the DefaultHttpClientFactory (and its background cleanup timer)
+        // if the race-upload feature is never used.
+        services.AddTransient<IRaceUploadCommunicationClient>(sp =>
+        {
+            var options = sp.GetRequiredService<IOptions<CatalogCommunicationOptions>>().Value;
+            var logger = sp.GetService<ILogger<RaceUploadCommunicationClient>>() ?? NullLogger<RaceUploadCommunicationClient>.Instance;
+            var cookieContainer = sp.GetRequiredService<CookieContainer>();
+
+            var handler = new HttpClientHandler
+            {
+                UseCookies = true,
+                CookieContainer = cookieContainer,
+                AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate | DecompressionMethods.Brotli,
+            };
+
+            var httpClient = new HttpClient(handler, disposeHandler: true)
+            {
+                BaseAddress = options.BaseUri,
+                Timeout = options.RequestTimeout,
+            };
+
+            return new RaceUploadCommunicationClient(httpClient, sp.GetRequiredService<IOptions<CatalogCommunicationOptions>>(), logger);
+        });
+
+        return services;
+    }
+}

Catalog.Communication/Models/AdminLoginRequest.cs

@@ -0,0 +1,10 @@
+namespace Catalog.Communication.Models;
+
+public sealed class AdminLoginRequest
+{
+    public required string Login { get; init; }
+
+    public required string Password { get; init; }
+
+    public string Command { get; init; } = "check";
+}

Catalog.Communication/Models/AdminPhotoEndpoint.cs

@@ -0,0 +1,8 @@
+namespace Catalog.Communication.Models;
+
+public enum AdminPhotoEndpoint
+{
+    Foto = 0,
+    TipoGara = 1,
+    LogFoto = 2,
+}

Catalog.Communication/Models/MediaFileResponse.cs

@@ -0,0 +1,16 @@
+using System.Net;
+
+namespace Catalog.Communication.Models;
+
+public sealed class MediaFileResponse
+{
+    public required HttpStatusCode StatusCode { get; init; }
+
+    public required byte[] Content { get; init; }
+
+    public string? ContentType { get; init; }
+
+    public string? FileName { get; init; }
+
+    public required IReadOnlyDictionary<string, IReadOnlyList<string>> Headers { get; init; }
+}

Catalog.Communication/Models/RaceFileUploadRequest.cs

@@ -0,0 +1,16 @@
+namespace Catalog.Communication.Models;
+
+public sealed class RaceFileUploadRequest
+{
+    public int? CodFile { get; init; }
+
+    public long? Id { get; init; }
+
+    public required string FileName { get; init; }
+
+    public required Stream FileStream { get; init; }
+
+    public string FormFieldName { get; init; } = "fileName";
+
+    public string? ContentType { get; init; }
+}

Catalog.Communication/Models/RaceImageRemoveRequest.cs

@@ -0,0 +1,10 @@
+namespace Catalog.Communication.Models;
+
+public sealed class RaceImageRemoveRequest
+{
+    public required long Id { get; init; }
+
+    public required int CodImage { get; init; }
+
+    public int? TotImgNumber { get; init; }
+}

Catalog.Communication/Models/RaceImageUploadRequest.cs

@@ -0,0 +1,18 @@
+namespace Catalog.Communication.Models;
+
+public sealed class RaceImageUploadRequest
+{
+    public required long Id { get; init; }
+
+    public required int CodImage { get; init; }
+
+    public int? TotImgNumber { get; init; }
+
+    public required string FileName { get; init; }
+
+    public required Stream FileStream { get; init; }
+
+    public string FormFieldName { get; init; } = "imgFile";
+
+    public string? ContentType { get; init; }
+}

Catalog.Communication/Models/RaceSaveRequest.cs

@@ -0,0 +1,26 @@
+namespace Catalog.Communication.Models;
+
+public sealed class RaceSaveRequest
+{
+    public long IdGara { get; init; }
+
+    public required string Description { get; init; }
+
+    public required DateOnly StartDate { get; init; }
+
+    public DateOnly? EndDate { get; init; }
+
+    public required long TipoGaraId { get; init; }
+
+    public int EventoInLinea { get; init; }
+
+    public int TipoIndicizzazione { get; init; }
+
+    public int FreeEvent { get; init; }
+
+    public string? PathBase { get; init; }
+
+    public string? Localita { get; init; }
+
+    public long? CodGara { get; init; }
+}

Catalog.Communication/Models/RawEndpointResponse.cs

@@ -0,0 +1,12 @@
+using System.Net;
+
+namespace Catalog.Communication.Models;
+
+public sealed class RawEndpointResponse
+{
+    public required HttpStatusCode StatusCode { get; init; }
+
+    public required string Body { get; init; }
+
+    public required IReadOnlyDictionary<string, IReadOnlyList<string>> Headers { get; init; }
+}

Catalog.Communication/Models/ReceiveFileUploadRequest.cs

@@ -0,0 +1,16 @@
+namespace Catalog.Communication.Models;
+
+public sealed class ReceiveFileUploadRequest
+{
+    public required string FileName { get; init; }
+
+    public required Stream FileStream { get; init; }
+
+    public required string DestinationPath { get; init; }
+
+    public bool OverwriteRemoteFile { get; init; }
+
+    public int? BufferSize { get; init; }
+
+    public string? ContentType { get; init; }
+}

Catalog.Communication/Models/UploadFileResponse.cs

@@ -0,0 +1,18 @@
+using System.Text.Json.Serialization;
+
+namespace Catalog.Communication.Models;
+
+public sealed class UploadFileResponse
+{
+    [JsonPropertyName("result")]
+    public bool Result { get; init; }
+
+    [JsonPropertyName("message")]
+    public string Message { get; init; } = string.Empty;
+
+    [JsonPropertyName("fileName")]
+    public string FileName { get; init; } = string.Empty;
+
+    [JsonPropertyName("fileNameLink")]
+    public string FileNameLink { get; init; } = string.Empty;
+}

Catalog.Communication/Models/UploadImageResponse.cs

@@ -0,0 +1,15 @@
+using System.Text.Json.Serialization;
+
+namespace Catalog.Communication.Models;
+
+public sealed class UploadImageResponse
+{
+    [JsonPropertyName("result")]
+    public bool Result { get; init; }
+
+    [JsonPropertyName("message")]
+    public string Message { get; init; } = string.Empty;
+
+    [JsonPropertyName("imgPath")]
+    public string ImgPath { get; init; } = string.Empty;
+}

Catalog.Communication/RaceUploadCommunicationClient.cs

@@ -0,0 +1,622 @@
+using System.Net;
+using System.Net.Http.Headers;
+using System.Text;
+using System.Text.Json;
+using System.Globalization;
+using Catalog.Communication.Abstractions;
+using Catalog.Communication.Models;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+
+namespace Catalog.Communication;
+
+public sealed class RaceUploadCommunicationClient : IRaceUploadCommunicationClient, IDisposable
+{
+    private const string AdminMenuPath = "admin/menu/Menu4.abl";
+    private const string PublicLogonPath = "Logon.abl";
+    private const string UsersPath = "Users.abl";
+    private const string Foto2Path = "Foto2.abl";
+    private const string ThumbnailPath = "foto";
+    private const string OriginalPath = "fotoOriginali";
+
+    private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web)
+    {
+        PropertyNameCaseInsensitive = true,
+    };
+
+    private readonly HttpClient _httpClient;
+    private readonly ILogger<RaceUploadCommunicationClient> _logger;
+    private readonly IOptions<CatalogCommunicationOptions> _options;
+    private bool _disposed;
+
+    public RaceUploadCommunicationClient(
+        HttpClient httpClient,
+        IOptions<CatalogCommunicationOptions> options,
+        ILogger<RaceUploadCommunicationClient> logger)
+    {
+        _httpClient = httpClient;
+        _options = options;
+        _logger = logger;
+    }
+
+    public void Dispose()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        _httpClient.Dispose();
+        _disposed = true;
+        GC.SuppressFinalize(this);
+    }
+
+    public Task<RawEndpointResponse> LoginAdminAsync(AdminLoginRequest request, CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(request);
+
+        var formFields = new Dictionary<string, string?>
+        {
+            ["login"] = request.Login,
+            ["pwd"] = request.Password,
+            ["cmdIU"] = request.Command,
+        };
+
+        return PostFormAsync(AdminMenuPath, formFields, "admin-login", cancellationToken);
+    }
+
+    public Task<RawEndpointResponse> LogoutAdminAsync(CancellationToken cancellationToken = default)
+    {
+        var formFields = new Dictionary<string, string?>
+        {
+            ["cmdIU"] = "login",
+        };
+
+        return PostFormAsync(AdminMenuPath, formFields, "admin-logout", cancellationToken);
+    }
+
+    public Task<UploadImageResponse?> UploadRaceImageAsync(RaceImageUploadRequest request, CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(request);
+
+        return PostMultipartAndParseUploadAsync<UploadImageResponse>(
+            GetAdminPagePath("Gara"),
+            "gara-upload-image",
+            request.FileStream,
+            request.FileName,
+            request.FormFieldName,
+            request.ContentType,
+            static fields =>
+            {
+                fields["cmd"] = "loadImg";
+            },
+            new Dictionary<string, string?>
+            {
+                ["id"] = request.Id.ToString(System.Globalization.CultureInfo.InvariantCulture),
+                ["codImage"] = request.CodImage.ToString(System.Globalization.CultureInfo.InvariantCulture),
+                ["totImgNumber"] = request.TotImgNumber?.ToString(System.Globalization.CultureInfo.InvariantCulture),
+            },
+            cancellationToken);
+    }
+
+    public Task<UploadImageResponse?> RemoveRaceImageAsync(RaceImageRemoveRequest request, CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(request);
+
+        var fields = new Dictionary<string, string?>
+        {
+            ["cmd"] = "removeImg",
+            ["id"] = request.Id.ToString(System.Globalization.CultureInfo.InvariantCulture),
+            ["codImage"] = request.CodImage.ToString(System.Globalization.CultureInfo.InvariantCulture),
+            ["totImgNumber"] = request.TotImgNumber?.ToString(System.Globalization.CultureInfo.InvariantCulture),
+        };
+
+        return PostFormAndParseUploadAsync<UploadImageResponse>(GetAdminPagePath("Gara"), fields, "gara-remove-image", cancellationToken);
+    }
+
+    public Task<UploadFileResponse?> UploadRaceFileAsync(RaceFileUploadRequest request, CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(request);
+
+        return PostMultipartAndParseUploadAsync<UploadFileResponse>(
+            GetAdminPagePath("Gara"),
+            "gara-upload-file",
+            request.FileStream,
+            request.FileName,
+            request.FormFieldName,
+            request.ContentType,
+            static fields =>
+            {
+                fields["cmd"] = "saveFile";
+            },
+            new Dictionary<string, string?>
+            {
+                ["codFile"] = request.CodFile?.ToString(System.Globalization.CultureInfo.InvariantCulture),
+                ["id"] = request.Id?.ToString(System.Globalization.CultureInfo.InvariantCulture),
+            },
+            cancellationToken);
+    }
+
+    public Task<RawEndpointResponse> SaveRaceAsync(RaceSaveRequest request, CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(request);
+
+        var formFields = new Dictionary<string, string?>
+        {
+            ["cmd"] = "asq",
+            ["act"] = "save",
+            ["id_gara"] = request.IdGara.ToString(CultureInfo.InvariantCulture),
+            ["descrizione"] = request.Description,
+            ["dataGaraInizio"] = request.StartDate.ToString("dd/MM/yyyy", CultureInfo.InvariantCulture),
+            ["dataGaraFine"] = (request.EndDate ?? request.StartDate).ToString("dd/MM/yyyy", CultureInfo.InvariantCulture),
+            ["id_tipoGara"] = request.TipoGaraId.ToString(CultureInfo.InvariantCulture),
+            ["flgEventoInLinea"] = request.EventoInLinea.ToString(CultureInfo.InvariantCulture),
+            ["flgTipoIndex"] = request.TipoIndicizzazione.ToString(CultureInfo.InvariantCulture),
+            ["flgFree"] = request.FreeEvent.ToString(CultureInfo.InvariantCulture),
+            ["pathBase"] = request.PathBase,
+            ["localita"] = request.Localita,
+            ["codGara"] = request.CodGara?.ToString(CultureInfo.InvariantCulture),
+        };
+
+        return PostFormAsync(GetAdminPagePath("Gara"), formFields, "gara-save", cancellationToken);
+    }
+
+    public Task<RawEndpointResponse> CreateRacePointsAsync(long raceId, CancellationToken cancellationToken = default)
+    {
+        var formFields = new Dictionary<string, string?>
+        {
+            ["cmd"] = "creaPuntiFoto",
+            ["id_gara"] = raceId.ToString(CultureInfo.InvariantCulture),
+        };
+
+        return PostFormAsync(GetAdminPagePath("Gara"), formFields, "gara-create-points", cancellationToken);
+    }
+
+    public Task<RawEndpointResponse> IndexRacePointAsync(long pointId, CancellationToken cancellationToken = default)
+    {
+        var formFields = new Dictionary<string, string?>
+        {
+            ["cmd"] = "indexFoto",
+            ["id_puntoFotoIdx"] = pointId.ToString(CultureInfo.InvariantCulture),
+        };
+
+        return PostFormAsync(GetAdminPagePath("Gara"), formFields, "gara-index-point", cancellationToken);
+    }
+
+    public Task<RawEndpointResponse> GetRaceDetailAsync(long raceId, CancellationToken cancellationToken = default)
+    {
+        var formFields = new Dictionary<string, string?>
+        {
+            ["cmd"] = "search",
+            ["id_gara"] = raceId.ToString(CultureInfo.InvariantCulture),
+        };
+
+        return PostFormAsync(GetAdminPagePath("Gara"), formFields, "gara-detail", cancellationToken);
+    }
+
+    public async Task<RawEndpointResponse> UploadFileToReceiverAsync(ReceiveFileUploadRequest request, CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(request);
+        ArgumentException.ThrowIfNullOrWhiteSpace(request.FileName);
+        ArgumentException.ThrowIfNullOrWhiteSpace(request.DestinationPath);
+        ArgumentNullException.ThrowIfNull(request.FileStream);
+
+        var payload = await ReadAllBytesAsync(request.FileStream, cancellationToken).ConfigureAwait(false);
+        var query = new Dictionary<string, string?>
+        {
+            ["name"] = request.FileName,
+            ["path"] = request.DestinationPath,
+            ["overwriteRemoteFile"] = request.OverwriteRemoteFile ? "true" : "false",
+            ["bs"] = request.BufferSize?.ToString(CultureInfo.InvariantCulture),
+        };
+
+        var path = AppendQuery(GetReceiveFilePath(), query);
+
+        return await ExecuteWithResilienceAsync(
+            () =>
+            {
+                var byteContent = new ByteArrayContent(payload);
+                byteContent.Headers.ContentType = new MediaTypeHeaderValue(request.ContentType ?? "application/octet-stream");
+
+                return new HttpRequestMessage(HttpMethod.Post, path)
+                {
+                    Content = byteContent,
+                };
+            },
+            ToRawResponseAsync,
+            "receiver-upload",
+            cancellationToken).ConfigureAwait(false);
+    }
+
+    public Task<RawEndpointResponse> ExecuteGaraCommandAsync(IReadOnlyDictionary<string, string?> formFields, CancellationToken cancellationToken = default)
+    {
+        return PostFormAsync(GetAdminPagePath("Gara"), formFields, "gara-command", cancellationToken);
+    }
+
+    public Task<RawEndpointResponse> ExecuteAdminPhotoCommandAsync(AdminPhotoEndpoint endpoint, IReadOnlyDictionary<string, string?> formFields, CancellationToken cancellationToken = default)
+    {
+        var path = endpoint switch
+        {
+            AdminPhotoEndpoint.Foto => GetAdminPagePath("Foto"),
+            AdminPhotoEndpoint.TipoGara => GetAdminPagePath("TipoGara"),
+            AdminPhotoEndpoint.LogFoto => GetAdminPagePath("LogFoto"),
+            _ => throw new ArgumentOutOfRangeException(nameof(endpoint), endpoint, "Unsupported endpoint."),
+        };
+
+        return PostFormAsync(path, formFields, $"photo-admin-{endpoint}", cancellationToken);
+    }
+
+    public Task<RawEndpointResponse> ExecutePublicLogonAsync(IReadOnlyDictionary<string, string?> formFields, CancellationToken cancellationToken = default)
+    {
+        return PostFormAsync(PublicLogonPath, formFields, "public-logon", cancellationToken);
+    }
+
+    public Task<RawEndpointResponse> ExecuteUsersAsync(HttpMethod method, IReadOnlyDictionary<string, string?>? formFields = null, CancellationToken cancellationToken = default)
+    {
+        return SendCommandAsync(method, UsersPath, formFields, "public-users", cancellationToken);
+    }
+
+    public Task<RawEndpointResponse> ExecuteFoto2Async(HttpMethod method, IReadOnlyDictionary<string, string?>? formFields = null, CancellationToken cancellationToken = default)
+    {
+        return SendCommandAsync(method, Foto2Path, formFields, "public-foto2", cancellationToken);
+    }
+
+    public Task<MediaFileResponse> DownloadThumbnailAsync(string filename, long? idFoto = null, CancellationToken cancellationToken = default)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(filename);
+        return DownloadFileAsync(ThumbnailPath, filename, idFoto, "media-thumbnail", cancellationToken);
+    }
+
+    public Task<MediaFileResponse> DownloadOriginalAsync(string filename, long? idFoto = null, CancellationToken cancellationToken = default)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(filename);
+        return DownloadFileAsync(OriginalPath, filename, idFoto, "media-original", cancellationToken);
+    }
+
+    private Task<RawEndpointResponse> SendCommandAsync(HttpMethod method, string path, IReadOnlyDictionary<string, string?>? formFields, string operationName, CancellationToken cancellationToken)
+    {
+        ArgumentNullException.ThrowIfNull(method);
+
+        if (method == HttpMethod.Get)
+        {
+            var relativePath = AppendQuery(path, formFields);
+            return GetAsync(relativePath, operationName, cancellationToken);
+        }
+
+        if (method == HttpMethod.Post)
+        {
+            return PostFormAsync(path, formFields ?? new Dictionary<string, string?>(), operationName, cancellationToken);
+        }
+
+        throw new NotSupportedException($"Only GET and POST are supported. Requested method: {method}.");
+    }
+
+    private Task<RawEndpointResponse> GetAsync(string relativePath, string operationName, CancellationToken cancellationToken)
+    {
+        return ExecuteWithResilienceAsync(
+            () => new HttpRequestMessage(HttpMethod.Get, relativePath),
+            ToRawResponseAsync,
+            operationName,
+            cancellationToken);
+    }
+
+    private Task<RawEndpointResponse> PostFormAsync(string relativePath, IReadOnlyDictionary<string, string?> formFields, string operationName, CancellationToken cancellationToken)
+    {
+        return ExecuteWithResilienceAsync(
+            () =>
+            {
+                var request = new HttpRequestMessage(HttpMethod.Post, relativePath)
+                {
+                    Content = BuildFormContent(formFields),
+                };
+
+                return request;
+            },
+            ToRawResponseAsync,
+            operationName,
+            cancellationToken);
+    }
+
+    private Task<TUpload?> PostFormAndParseUploadAsync<TUpload>(string relativePath, IReadOnlyDictionary<string, string?> formFields, string operationName, CancellationToken cancellationToken)
+    {
+        return ExecuteWithResilienceAsync(
+            () =>
+            {
+                var request = new HttpRequestMessage(HttpMethod.Post, relativePath)
+                {
+                    Content = BuildFormContent(formFields),
+                };
+
+                return request;
+            },
+            async (response, token) =>
+            {
+                var raw = await ToRawResponseAsync(response, token).ConfigureAwait(false);
+                return ParseSingleItemArray<TUpload>(raw.Body);
+            },
+            operationName,
+            cancellationToken);
+    }
+
+    private async Task<TUpload?> PostMultipartAndParseUploadAsync<TUpload>(
+        string relativePath,
+        string operationName,
+        Stream fileStream,
+        string fileName,
+        string formFieldName,
+        string? contentType,
+        Action<Dictionary<string, string?>> configureRequiredFields,
+        IReadOnlyDictionary<string, string?> optionalFields,
+        CancellationToken cancellationToken)
+    {
+        ArgumentNullException.ThrowIfNull(fileStream);
+        ArgumentException.ThrowIfNullOrWhiteSpace(fileName);
+        ArgumentException.ThrowIfNullOrWhiteSpace(formFieldName);
+
+        var payload = await ReadAllBytesAsync(fileStream, cancellationToken).ConfigureAwait(false);
+
+        return await ExecuteWithResilienceAsync(
+            () =>
+            {
+                var multipart = new MultipartFormDataContent();
+                var fields = new Dictionary<string, string?>();
+                configureRequiredFields(fields);
+
+                foreach (var field in fields)
+                {
+                    if (string.IsNullOrWhiteSpace(field.Value))
+                    {
+                        continue;
+                    }
+
+                    multipart.Add(new StringContent(field.Value, Encoding.UTF8), field.Key);
+                }
+
+                foreach (var field in optionalFields)
+                {
+                    if (string.IsNullOrWhiteSpace(field.Value))
+                    {
+                        continue;
+                    }
+
+                    multipart.Add(new StringContent(field.Value, Encoding.UTF8), field.Key);
+                }
+
+                var fileContent = new ByteArrayContent(payload);
+                fileContent.Headers.ContentType = new MediaTypeHeaderValue(contentType ?? "application/octet-stream");
+                multipart.Add(fileContent, formFieldName, fileName);
+
+                return new HttpRequestMessage(HttpMethod.Post, relativePath)
+                {
+                    Content = multipart,
+                };
+            },
+            async (response, token) =>
+            {
+                var raw = await ToRawResponseAsync(response, token).ConfigureAwait(false);
+                return ParseSingleItemArray<TUpload>(raw.Body);
+            },
+            operationName,
+            cancellationToken).ConfigureAwait(false);
+    }
+
+    private Task<MediaFileResponse> DownloadFileAsync(string basePath, string filename, long? idFoto, string operationName, CancellationToken cancellationToken)
+    {
+        var escapedFileName = Uri.EscapeDataString(filename);
+        var relativePath = idFoto.HasValue
+            ? $"{basePath}/{escapedFileName}?id_foto={idFoto.Value.ToString(System.Globalization.CultureInfo.InvariantCulture)}"
+            : $"{basePath}/{escapedFileName}";
+
+        return ExecuteWithResilienceAsync(
+            () => new HttpRequestMessage(HttpMethod.Get, relativePath),
+            async (response, token) =>
+            {
+                var content = await response.Content.ReadAsByteArrayAsync(token).ConfigureAwait(false);
+                return new MediaFileResponse
+                {
+                    StatusCode = response.StatusCode,
+                    Content = content,
+                    ContentType = response.Content.Headers.ContentType?.MediaType,
+                    FileName = response.Content.Headers.ContentDisposition?.FileNameStar ?? response.Content.Headers.ContentDisposition?.FileName,
+                    Headers = BuildHeaders(response),
+                };
+            },
+            operationName,
+            cancellationToken);
+    }
+
+    private async Task<TResponse> ExecuteWithResilienceAsync<TResponse>(
+        Func<HttpRequestMessage> requestFactory,
+        Func<HttpResponseMessage, CancellationToken, Task<TResponse>> responseFactory,
+        string operationName,
+        CancellationToken cancellationToken)
+    {
+        var options = _options.Value;
+        Exception? lastException = null;
+
+        for (var attempt = 0; attempt <= options.RetryCount; attempt++)
+        {
+            using var request = requestFactory();
+            using var timeoutCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+            timeoutCts.CancelAfter(options.RequestTimeout);
+
+            HttpResponseMessage? response = null;
+
+            try
+            {
+                response = await _httpClient
+                    .SendAsync(request, HttpCompletionOption.ResponseHeadersRead, timeoutCts.Token)
+                    .ConfigureAwait(false);
+
+                if (IsRetryableStatusCode(response.StatusCode) && attempt < options.RetryCount)
+                {
+                    _logger.LogWarning(
+                        "Operation {OperationName} received retryable status code {StatusCode} at attempt {Attempt}/{MaxAttempts}.",
+                        operationName,
+                        (int)response.StatusCode,
+                        attempt + 1,
+                        options.RetryCount + 1);
+
+                    await DelayBeforeRetryAsync(options, attempt, cancellationToken).ConfigureAwait(false);
+                    continue;
+                }
+
+                return await responseFactory(response, cancellationToken).ConfigureAwait(false);
+            }
+            catch (OperationCanceledException ex) when (!cancellationToken.IsCancellationRequested)
+            {
+                lastException = ex;
+
+                if (attempt < options.RetryCount)
+                {
+                    _logger.LogWarning(ex, "Operation {OperationName} timed out at attempt {Attempt}/{MaxAttempts}.", operationName, attempt + 1, options.RetryCount + 1);
+                    await DelayBeforeRetryAsync(options, attempt, cancellationToken).ConfigureAwait(false);
+                    continue;
+                }
+
+                _logger.LogError(ex, "Operation {OperationName} timed out after {MaxAttempts} attempts.", operationName, options.RetryCount + 1);
+                throw;
+            }
+            catch (HttpRequestException ex)
+            {
+                lastException = ex;
+
+                if (attempt < options.RetryCount)
+                {
+                    _logger.LogWarning(ex, "Operation {OperationName} failed with transient HTTP error at attempt {Attempt}/{MaxAttempts}.", operationName, attempt + 1, options.RetryCount + 1);
+                    await DelayBeforeRetryAsync(options, attempt, cancellationToken).ConfigureAwait(false);
+                    continue;
+                }
+
+                _logger.LogError(ex, "Operation {OperationName} failed with HTTP error after {MaxAttempts} attempts.", operationName, options.RetryCount + 1);
+                throw;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Operation {OperationName} failed with unexpected error at attempt {Attempt}/{MaxAttempts}.", operationName, attempt + 1, options.RetryCount + 1);
+                throw;
+            }
+            finally
+            {
+                response?.Dispose();
+            }
+        }
+
+        throw new HttpRequestException($"Operation '{operationName}' failed after {options.RetryCount + 1} attempts.", lastException);
+    }
+
+    private static bool IsRetryableStatusCode(HttpStatusCode statusCode)
+    {
+        return statusCode is HttpStatusCode.RequestTimeout
+            or HttpStatusCode.TooManyRequests
+            or HttpStatusCode.BadGateway
+            or HttpStatusCode.ServiceUnavailable
+            or HttpStatusCode.GatewayTimeout
+            or HttpStatusCode.InternalServerError;
+    }
+
+    private static async Task DelayBeforeRetryAsync(CatalogCommunicationOptions options, int attempt, CancellationToken cancellationToken)
+    {
+        var delay = TimeSpan.FromMilliseconds(options.RetryBaseDelay.TotalMilliseconds * Math.Pow(2, attempt));
+        await Task.Delay(delay, cancellationToken).ConfigureAwait(false);
+    }
+
+    private static FormUrlEncodedContent BuildFormContent(IReadOnlyDictionary<string, string?> formFields)
+    {
+        var pairs = formFields
+            .Where(kvp => !string.IsNullOrWhiteSpace(kvp.Value))
+            .Select(kvp => new KeyValuePair<string, string>(kvp.Key, kvp.Value!));
+
+        return new FormUrlEncodedContent(pairs);
+    }
+
+    private static string AppendQuery(string path, IReadOnlyDictionary<string, string?>? query)
+    {
+        if (query is null || query.Count == 0)
+        {
+            return path;
+        }
+
+        var encodedPairs = query
+            .Where(kvp => !string.IsNullOrWhiteSpace(kvp.Value))
+            .Select(kvp => $"{Uri.EscapeDataString(kvp.Key)}={Uri.EscapeDataString(kvp.Value!)}")
+            .ToArray();
+
+        if (encodedPairs.Length == 0)
+        {
+            return path;
+        }
+
+        var separator = path.Contains('?', StringComparison.Ordinal) ? "&" : "?";
+        return string.Concat(path, separator, string.Join("&", encodedPairs));
+    }
+
+    private static async Task<RawEndpointResponse> ToRawResponseAsync(HttpResponseMessage response, CancellationToken cancellationToken)
+    {
+        var body = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+
+        return new RawEndpointResponse
+        {
+            StatusCode = response.StatusCode,
+            Body = body,
+            Headers = BuildHeaders(response),
+        };
+    }
+
+    private static IReadOnlyDictionary<string, IReadOnlyList<string>> BuildHeaders(HttpResponseMessage response)
+    {
+        var headers = new Dictionary<string, IReadOnlyList<string>>(StringComparer.OrdinalIgnoreCase);
+
+        foreach (var header in response.Headers)
+        {
+            headers[header.Key] = header.Value.ToArray();
+        }
+
+        foreach (var header in response.Content.Headers)
+        {
+            headers[header.Key] = header.Value.ToArray();
+        }
+
+        return headers;
+    }
+
+    private static TUpload? ParseSingleItemArray<TUpload>(string json)
+    {
+        if (string.IsNullOrWhiteSpace(json))
+        {
+            return default;
+        }
+
+        var items = JsonSerializer.Deserialize<List<TUpload>>(json, JsonOptions);
+        return items is { Count: > 0 } ? items[0] : default;
+    }
+
+    private static async Task<byte[]> ReadAllBytesAsync(Stream stream, CancellationToken cancellationToken)
+    {
+        if (stream.CanSeek)
+        {
+            stream.Position = 0;
+        }
+
+        using var memoryStream = new MemoryStream();
+        await stream.CopyToAsync(memoryStream, cancellationToken).ConfigureAwait(false);
+        return memoryStream.ToArray();
+    }
+
+    private string GetAdminPagePath(string pageName)
+    {
+        var basePath = _options.Value.AdminPageBasePath.Trim('/');
+        return $"{basePath}/{pageName}.abl";
+    }
+
+    private string GetReceiveFilePath()
+    {
+        var value = _options.Value.ReceiveFilePath;
+        if (string.IsNullOrWhiteSpace(value))
+        {
+            return "ReceiveFile.abl";
+        }
+
+        return value.Trim();
+    }
+}

Catalog.sln

@@ -15,6 +15,10 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MaddoShared.Tests", "MaddoS
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MaddoShared.Benchmarks", "MaddoShared.Benchmarks\MaddoShared.Benchmarks.csproj", "{07499348-8C15-4DCC-8316-4AD121A43C38}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Catalog.Communication", "Catalog.Communication\Catalog.Communication.csproj", "{EF5D3B7E-F380-4976-A0A9-085FEA157F79}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MaddoShared.ImageSharpTests", "MaddoShared.ImageSharpTests\MaddoShared.ImageSharpTests.csproj", "{1528903F-3BF9-599C-2DD0-0AF7B5706675}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -73,6 +77,30 @@ Global
 		{07499348-8C15-4DCC-8316-4AD121A43C38}.Release|x64.Build.0 = Release|Any CPU
 		{07499348-8C15-4DCC-8316-4AD121A43C38}.Release|x86.ActiveCfg = Release|Any CPU
 		{07499348-8C15-4DCC-8316-4AD121A43C38}.Release|x86.Build.0 = Release|Any CPU
+		{EF5D3B7E-F380-4976-A0A9-085FEA157F79}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{EF5D3B7E-F380-4976-A0A9-085FEA157F79}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{EF5D3B7E-F380-4976-A0A9-085FEA157F79}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{EF5D3B7E-F380-4976-A0A9-085FEA157F79}.Debug|x64.Build.0 = Debug|Any CPU
+		{EF5D3B7E-F380-4976-A0A9-085FEA157F79}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{EF5D3B7E-F380-4976-A0A9-085FEA157F79}.Debug|x86.Build.0 = Debug|Any CPU
+		{EF5D3B7E-F380-4976-A0A9-085FEA157F79}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{EF5D3B7E-F380-4976-A0A9-085FEA157F79}.Release|Any CPU.Build.0 = Release|Any CPU
+		{EF5D3B7E-F380-4976-A0A9-085FEA157F79}.Release|x64.ActiveCfg = Release|Any CPU
+		{EF5D3B7E-F380-4976-A0A9-085FEA157F79}.Release|x64.Build.0 = Release|Any CPU
+		{EF5D3B7E-F380-4976-A0A9-085FEA157F79}.Release|x86.ActiveCfg = Release|Any CPU
+		{EF5D3B7E-F380-4976-A0A9-085FEA157F79}.Release|x86.Build.0 = Release|Any CPU
+		{1528903F-3BF9-599C-2DD0-0AF7B5706675}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{1528903F-3BF9-599C-2DD0-0AF7B5706675}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{1528903F-3BF9-599C-2DD0-0AF7B5706675}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{1528903F-3BF9-599C-2DD0-0AF7B5706675}.Debug|x64.Build.0 = Debug|Any CPU
+		{1528903F-3BF9-599C-2DD0-0AF7B5706675}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{1528903F-3BF9-599C-2DD0-0AF7B5706675}.Debug|x86.Build.0 = Debug|Any CPU
+		{1528903F-3BF9-599C-2DD0-0AF7B5706675}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{1528903F-3BF9-599C-2DD0-0AF7B5706675}.Release|Any CPU.Build.0 = Release|Any CPU
+		{1528903F-3BF9-599C-2DD0-0AF7B5706675}.Release|x64.ActiveCfg = Release|Any CPU
+		{1528903F-3BF9-599C-2DD0-0AF7B5706675}.Release|x64.Build.0 = Release|Any CPU
+		{1528903F-3BF9-599C-2DD0-0AF7B5706675}.Release|x86.ActiveCfg = Release|Any CPU
+		{1528903F-3BF9-599C-2DD0-0AF7B5706675}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -80,6 +108,7 @@ Global
 	GlobalSection(NestedProjects) = preSolution
 		{AEBFE9E3-277C-4A7B-8448-145D1B11998B} = {A3D50937-74F6-4DC8-8D89-B534B484C0F9}
 		{59952BE8-20B4-4BF2-9367-705F41395265} = {5F0BEF23-B1EA-4100-A772-DC455D40B1C1}
+		{EF5D3B7E-F380-4976-A0A9-085FEA157F79} = {A3D50937-74F6-4DC8-8D89-B534B484C0F9}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {0E3ABC63-8601-4DAC-AFEA-33F3E8E36757}

CatalogLib/CatalogLib.csproj

@@ -1,196 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectGuid>{D27ACCF2-80FC-4DE8-AEB8-351FF076E6D5}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>CatalogLib</RootNamespace>
-    <AssemblyName>CatalogLib</AssemblyName>
-    <TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <SccProjectName>SAK</SccProjectName>
-    <SccLocalPath>SAK</SccLocalPath>
-    <SccAuxPath>SAK</SccAuxPath>
-    <SccProvider>SAK</SccProvider>
-    <TargetFrameworkProfile />
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
-    <DebugSymbols>true</DebugSymbols>
-    <OutputPath>bin\x64\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <DebugType>full</DebugType>
-    <PlatformTarget>x64</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
-    <OutputPath>bin\x64\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <Optimize>true</Optimize>
-    <DebugType>pdbonly</DebugType>
-    <PlatformTarget>x64</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="Microsoft.Win32.Primitives, Version=4.0.2.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <HintPath>..\packages\Microsoft.Win32.Primitives.4.3.0\lib\net46\Microsoft.Win32.Primitives.dll</HintPath>
-    </Reference>
-    <Reference Include="Newtonsoft.Json, Version=9.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
-      <HintPath>..\packages\Newtonsoft.Json.9.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
-      <Private>True</Private>
-    </Reference>
-    <Reference Include="SixLabors.Core, Version=0.1.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\SixLabors.Core.1.0.0-beta0002\lib\netstandard1.1\SixLabors.Core.dll</HintPath>
-    </Reference>
-    <Reference Include="SixLabors.Fonts, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\SixLabors.Fonts.1.0.0-beta0001\lib\netstandard1.3\SixLabors.Fonts.dll</HintPath>
-    </Reference>
-    <Reference Include="SixLabors.ImageSharp, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\SixLabors.ImageSharp.1.0.0-beta0001\lib\netstandard1.3\SixLabors.ImageSharp.dll</HintPath>
-    </Reference>
-    <Reference Include="SixLabors.ImageSharp.Drawing, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\SixLabors.ImageSharp.Drawing.1.0.0-beta0001\lib\netstandard1.1\SixLabors.ImageSharp.Drawing.dll</HintPath>
-    </Reference>
-    <Reference Include="SixLabors.Shapes, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\SixLabors.Shapes.1.0.0-beta0001\lib\netstandard1.1\SixLabors.Shapes.dll</HintPath>
-    </Reference>
-    <Reference Include="SixLabors.Shapes.Text, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\SixLabors.Shapes.Text.1.0.0-beta0001\lib\netstandard1.1\SixLabors.Shapes.Text.dll</HintPath>
-    </Reference>
-    <Reference Include="System" />
-    <Reference Include="System.AppContext, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.AppContext.4.3.0\lib\net46\System.AppContext.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Buffers, Version=4.0.2.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.Buffers.4.4.0\lib\netstandard1.1\System.Buffers.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Collections.Immutable, Version=1.2.2.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.Collections.Immutable.1.4.0\lib\portable-net45+win8+wp8+wpa81\System.Collections.Immutable.dll</HintPath>
-    </Reference>
-    <Reference Include="System.ComponentModel.Composition" />
-    <Reference Include="System.Console, Version=4.0.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.Console.4.3.0\lib\net46\System.Console.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Core" />
-    <Reference Include="System.Diagnostics.DiagnosticSource, Version=4.0.1.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.Diagnostics.DiagnosticSource.4.3.0\lib\net46\System.Diagnostics.DiagnosticSource.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Drawing" />
-    <Reference Include="System.Globalization.Calendars, Version=4.0.2.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.Globalization.Calendars.4.3.0\lib\net46\System.Globalization.Calendars.dll</HintPath>
-    </Reference>
-    <Reference Include="System.IO.Compression, Version=4.1.2.0, Culture=neutral, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.IO.Compression.4.3.0\lib\net46\System.IO.Compression.dll</HintPath>
-    </Reference>
-    <Reference Include="System.IO.Compression.FileSystem" />
-    <Reference Include="System.IO.Compression.ZipFile, Version=4.0.2.0, Culture=neutral, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.IO.Compression.ZipFile.4.3.0\lib\net46\System.IO.Compression.ZipFile.dll</HintPath>
-    </Reference>
-    <Reference Include="System.IO.FileSystem, Version=4.0.2.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.IO.FileSystem.4.3.0\lib\net46\System.IO.FileSystem.dll</HintPath>
-    </Reference>
-    <Reference Include="System.IO.FileSystem.Primitives, Version=4.0.2.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.IO.FileSystem.Primitives.4.3.0\lib\net46\System.IO.FileSystem.Primitives.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Memory, Version=4.0.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.Memory.4.4.0-preview2-25405-01\lib\netstandard1.0\System.Memory.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Net.Http, Version=4.1.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.Net.Http.4.3.0\lib\net46\System.Net.Http.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Net.Sockets, Version=4.1.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.Net.Sockets.4.3.0\lib\net46\System.Net.Sockets.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Numerics" />
-    <Reference Include="System.Numerics.Vectors, Version=4.1.3.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.Numerics.Vectors.4.4.0\lib\net46\System.Numerics.Vectors.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Runtime.CompilerServices.Unsafe, Version=4.0.3.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.Runtime.CompilerServices.Unsafe.4.4.0\lib\netstandard1.0\System.Runtime.CompilerServices.Unsafe.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Runtime.InteropServices.RuntimeInformation, Version=4.0.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.Runtime.InteropServices.RuntimeInformation.4.3.0\lib\net45\System.Runtime.InteropServices.RuntimeInformation.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Security.Cryptography.Algorithms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.Security.Cryptography.Algorithms.4.3.0\lib\net46\System.Security.Cryptography.Algorithms.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Security.Cryptography.Encoding, Version=4.0.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.Security.Cryptography.Encoding.4.3.0\lib\net46\System.Security.Cryptography.Encoding.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Security.Cryptography.Primitives, Version=4.0.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.Security.Cryptography.Primitives.4.3.0\lib\net46\System.Security.Cryptography.Primitives.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Security.Cryptography.X509Certificates, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.Security.Cryptography.X509Certificates.4.3.0\lib\net46\System.Security.Cryptography.X509Certificates.dll</HintPath>
-    </Reference>
-    <Reference Include="System.ValueTuple, Version=4.0.2.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.ValueTuple.4.4.0\lib\netstandard1.0\System.ValueTuple.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Xml.Linq" />
-    <Reference Include="System.Data.DataSetExtensions" />
-    <Reference Include="Microsoft.CSharp" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Xml" />
-    <Reference Include="System.Xml.ReaderWriter, Version=4.1.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.Xml.ReaderWriter.4.3.0\lib\net46\System.Xml.ReaderWriter.dll</HintPath>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="Class1.cs" />
-    <Compile Include="Enums.cs" />
-    <Compile Include="IImageProcessor.cs" />
-    <Compile Include="ImageCreator.cs" />
-    <Compile Include="ImageCreator2.cs" />
-    <Compile Include="ImgSharpCreator.cs" />
-    <Compile Include="PicSettings.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="SinglePicData.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\CatalogVbLib\CatalogVbLib.vbproj">
-      <Project>{44465926-240d-473f-90b8-786ba4384406}</Project>
-      <Name>CatalogVbLib</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\MaddoLibrary\MaddoLibrary.Base.NET46\MaddoLibrary.Base.NET46.csproj">
-      <Project>{e93daae6-4aa9-4a45-afb6-58209b3ad3c9}</Project>
-      <Name>MaddoLibrary.Base.NET46</Name>
-    </ProjectReference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="app.config" />
-    <None Include="packages.config" />
-    <None Include="stylecop.json" />
-  </ItemGroup>
-  <ItemGroup>
-    <Folder Include="Settings\" />
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
-  -->
-</Project>

CatalogLib/Class1.cs

@@ -1,12 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace CatalogLib
-{
-    public class Class1
-    {
-    }
-}

CatalogLib/Enums.cs

@@ -1,41 +0,0 @@
-namespace CatalogLib
-{
-    public enum Positions
-    {
-        Alto,
-        Centro,
-        Basso
-    }
-
-    public enum Alignments
-    {
-        Sinistra,
-        Centro,
-        Destra
-    }
-
-    public enum ResizeModes
-    {
-        Bicubic,
-        Box,
-        CatmullRom,
-        Hermite,
-        Lanczos2,
-        Lanczos3,
-        Lanczos5,
-        Lanczos8,
-        MitchellNetravali,
-        NearestNeighbor,
-        Robidoux,
-        Spline,
-        Triangle,
-        Welch
-
-    }
-
-    public enum ResizeDimensions
-    {
-        LatoLungo,
-        LatoCorto
-    }
-}

CatalogLib/IImageProcessor.cs

@@ -1,14 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace CatalogLib
-{
-    public interface IImageProcessor
-    {
-        void Start(FileInfo workFile);
-    }
-}

CatalogLib/ImageCreator.cs

@@ -1,618 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Drawing.Drawing2D;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Drawing;
-using System.Drawing.Imaging;
-using CatalogVbLib;
-
-namespace CatalogLib
-{
-	public class ImageCreator
-	{
-
-		#region Variabili
-
-		private SinglePicData _singlePicData;
-		private PicSettings _picSettings;
-
-		private Rotazione _rotation;
-
-		//private bool FotoRuotaADestra = false;
-
-		//private bool FotoRuotaASinistra = false;
-		private string TempMinText = "";
-		//Private crFont1 As Font
-
-		private string _NomeFileChild;
-		private DirectoryInfo _SourceDir;
-		private DirectoryInfo _DestDirStart;
-
-		private DirectoryInfo _DestDir;
-
-		private FileInfo _workFile;
-		private string testoFirma;
-		private string testoFirmaV;
-		private int alphaScelta;
-		private int _dimensioneStandard;
-		private int _dimensioneStandardMiniatura;
-		private DateTime dataFoto;
-		private DateTime dataPartenzaI;
-		private string testoOrario;
-		private string testoFirmaPiccola;
-		private Size thumbSizeSmall;
-		private Size thumbSizeBig;
-		private string nomeFileSmall;
-		private string nomeFileBig;
-
-		private string nomeFileBig2;
-		private float yPosFromBottom;
-		private float yPosFromBottom1;
-		private float yPosFromBottom2;
-		private float yPosFromBottom3;
-		private float yPosFromBottom4;
-
-		public string NomeFileChild
-		{
-			get { return _NomeFileChild; }
-			set { _NomeFileChild = value; }
-		}
-
-		public DirectoryInfo DestDirStart
-		{
-			get { return _DestDirStart; }
-			set { _DestDirStart = value; }
-		}
-
-		public DirectoryInfo SourceDir
-		{
-			get { return _SourceDir; }
-			set { _SourceDir = value; }
-		}
-
-		public DirectoryInfo DestDir
-		{
-			get { return _DestDir; }
-			set { _DestDir = value; }
-		}
-
-		public FileInfo WorkFile
-		{
-			get { return _workFile; }
-			set { _workFile = value; }
-		}
-
-		#endregion
-
-		//public ImageCreator(string nomeFileChild, DirectoryInfo sourceDir, DirectoryInfo destDir, DirectoryInfo destDirStart)
-		//{
-		//    this.NomeFileChild = nomeFileChild;
-		//    SourceDir = sourceDir;
-		//    DestDir = destDir;
-		//    DestDirStart = destDirStart;
-		//    WorkFile = new FileInfo(nomeFileChild);
-		//}
-
-		//public ImageCreator(string nomeFileChild, DirectoryInfo sourceDir, DirectoryInfo destDir)
-		//{
-		//    NomeFileChild = nomeFileChild;
-		//    DestDir = destDir;
-		//}
-
-		//public ImageCreator(FileInfo file, DirectoryInfo destination)
-		//{
-		//    WorkFile = file;
-		//    DestDir = destination;
-		//}
-
-		public ImageCreator(SinglePicData picData, PicSettings picSettings)
-		{
-			
-		}
-
-		/// <summary>
-		/// Elabora l'immagine
-		/// </summary>
-		/// <param name="info">Non ne ho idea. ToDo: capire a che serve</param>
-		public void CreaImmagineThread(string info)
-		{
-
-			//CatalogLib.PicSettings ps = new CatalogLib.PicSettings();
-
-			PreparaVariabili();
-
-			// Workfile deve essere impostato esternamente. ToDo: passarlo come parametro così da potere riutilizzare la classe senza eliminarla e ricrearla
-			Image g = Image.FromFile(WorkFile.FullName);
-
-			ImpostaTestoExtra(g);
-
-			// Rotazione immagine in base ai dati EXIF
-			Rotation(ref g);
-
-			// Impostazione del formato
-			// todo: mettere una selezione più specifica invece di assumere jpg
-			ImageFormat currentFormat = g.RawFormat;
-			if (_picSettings.UsaForzaJpg)
-			{
-				currentFormat = ImageFormat.Jpeg;
-			}
-
-			PrepareThumbnailSize(g);
-
-			// big image resolution
-			var imgOutputBig = new Bitmap(g, thumbSizeBig.Width, thumbSizeBig.Height);
-			imgOutputBig.SetResolution(g.HorizontalResolution, g.VerticalResolution);
-
-
-			if (_picSettings.CreaMiniature)
-			{
-
-				CreaMiniature(g, imgOutputBig, currentFormat);
-			}
-
-			
-
-
-
-
-		}
-
-
-		private void Rotation(ref System.Drawing.Image g)
-		{
-			//FotoRuotaADestra = false;
-			//FotoRuotaASinistra = false;
-			_rotation = Rotazione.Normale;
-
-			if (_picSettings.GeneraleRotazioneAutomatica)
-			{
-				// ci sono dati exif
-				if (g.PropertyIdList.Length > 0)
-				{
-					ExifReader DatiExif = new ExifReader((Bitmap)g);
-
-					switch (DatiExif.Orientation)
-					{
-						case ExifReader.Orientations.BottomLeft:
-
-							break;
-						case ExifReader.Orientations.BottomRight:
-
-							break;
-						case ExifReader.Orientations.LeftTop:
-
-							break;
-						case ExifReader.Orientations.LftBottom:
-							//FotoRuotaASinistra = true;
-							_rotation = Rotazione.Sinistra;
-							break;
-						case ExifReader.Orientations.RightBottom:
-
-							break;
-						case ExifReader.Orientations.RightTop:
-
-							break;
-						case ExifReader.Orientations.TopLeft:
-
-							break;
-						case ExifReader.Orientations.TopRight:
-
-							break;
-					}
-				}
-			}
-
-			if (_rotation == Rotazione.Sinistra)
-			{
-				g.RotateFlip(RotateFlipType.Rotate270FlipNone);
-			}else
-			if (_rotation == Rotazione.Destra)
-			{
-				g.RotateFlip(RotateFlipType.Rotate90FlipNone);
-			}
-			// todo: capire quando va ruotato a destra
-		}
-
-		/// <summary>
-		/// Aggiunge orario e tempo gara
-		/// </summary>
-		/// <param name="g"></param>
-		private void ImpostaTestoExtra(Image g)
-		{
-			if (_picSettings.UsaOrarioTestoApplicare ||
-				_picSettings.UsaTempoGaraTestoApplicare ||
-				_picSettings.UsaOrarioMiniatura ||
-				_picSettings.TestoMin ||
-				_picSettings.AggTempoGaraMin ||
-				_picSettings.AggNumTempMin)
-			{
-				if (g.PropertyIdList.Length > 0) //ci sono dati exif
-				{
-					var datiExix = new ExifReader((Bitmap)g);
-					dataFoto = datiExix.DateTimeOriginal;
-					testoFirma = _picSettings.TestoFirmaStart;
-					testoFirmaV = _picSettings.TestoFirmaStartV;
-
-					if (dataFoto.Year != 1)
-					{
-						testoFirmaPiccola = dataFoto.ToShortDateString();
-						if (_picSettings.UsaOrarioTestoApplicare)
-						{
-							testoFirma = $"{testoFirma} {dataFoto.ToShortDateString()} {dataFoto.ToLongDateString()}";
-							testoFirmaV = $"{testoFirmaV} {dataFoto.ToShortDateString()} {dataFoto.ToLongDateString()}";
-							//testoFirma = string.Concat(testoFirma, " ", dataFoto.ToShortDateString(), " ", dataFoto.ToLongDateString());
-							//testoFirmaV = string.Concat(testoFirmaV, " ", dataFoto.ToShortDateString(), " ", dataFoto.ToLongDateString());
-
-						}
-						if (_picSettings.UsaTempoGaraTestoApplicare)
-						{
-							//TimeSpan orario = dataPartenzaI - dataFoto;
-
-							string orarioString = (dataPartenzaI - dataFoto).ToString(@"hh\:mm\:ss");
-
-							testoFirma = $"{testoFirma} {testoOrario} {orarioString}";
-							testoFirmaV = $"{testoFirmaV} {testoOrario} {orarioString}";
-
-							//testoFirma = string.Concat(testoFirma, " ", testoOrario, orario.ToString(@"hh\:mm\:ss"));
-							//testoFirmaV = string.Concat(testoFirmaV, " ", testoOrario, orario.ToString(@"hh\:mm\:ss"));
-						}
-					}
-				}
-			}
-			else
-			{
-				testoFirma = _picSettings.TestoFirmaStart;
-				testoFirmaV = _picSettings.TestoFirmaStartV;
-			}
-		}
-
-		/// <summary>
-		/// Preparazione delle variabili a valori di default e caricamento da impostazioni
-		/// </summary>
-		private void PreparaVariabili()
-		{
-			alphaScelta = (int)(255 * (100 - _picSettings.Trasparenza) / 100);
-			testoFirma = string.Empty;
-			testoFirmaV = string.Empty;
-			dataPartenzaI = _picSettings.DataPartenza;
-			testoOrario = _picSettings.TestoOrario;
-			if (testoOrario.Length > 0)
-			{
-				testoOrario += " ";
-			}
-			testoFirmaPiccola = string.Empty;
-			thumbSizeSmall = new Size();
-			thumbSizeBig = new Size();
-			nomeFileSmall = string.Empty;
-			nomeFileBig2 = string.Empty;
-			nomeFileBig = string.Empty;
-			_dimensioneStandard = _picSettings.DimStandard;
-			_dimensioneStandardMiniatura = _picSettings.DimStandardMiniatura;
-
-			nomeFileSmall = _picSettings.Suffisso + WorkFile.Name;
-			nomeFileBig = WorkFile.Name;
-		}
-
-		private void PrepareThumbnailSize(Image g)
-		{
-			if (g.Width > g.Height)
-			{
-				thumbSizeSmall = NewthumbSize(g.Width, g.Height, CatalogVbLib.PicSettings.LarghezzaSmall, "Larghezza");
-				//Size sizeOrig = new Size(g.Width, g.Height);
-				//thumbSizeBig = sizeOrig;
-				
-				thumbSizeBig = new Size(g.Width, g.Height);
-			}
-			else
-			{
-				thumbSizeSmall = NewthumbSize(g.Width, g.Height, CatalogVbLib.PicSettings.AltezzaSmall, "Altezza");
-				
-				thumbSizeBig = new Size(g.Width, g.Height);
-			}
-		}
-
-		private void CreaMiniature(Image g, Bitmap imgOutputBig, ImageFormat thisFormat)
-		{
-//            CatalogLib.PicSettings ps = new PicSettings();
-
-			if (_picSettings.TestoMin)
-			{
-				testoFirmaPiccola = nomeFileBig;
-			}
-			else if (_picSettings.AggNumTempMin)
-			{
-				testoFirmaPiccola = nomeFileBig + " ";
-			}
-
-			Font crFont1;
-			Font crFont2;
-			SizeF crSize1 = new SizeF();
-			SizeF crSize2 = new SizeF();
-
-			if (_picSettings.CreaMiniature)
-			{
-				if (!_picSettings.AggiungiScritteMiniature)
-				{
-					if (string.Equals(_picSettings.DirectorySorgente, _picSettings.DirectoryDestinazione, StringComparison.CurrentCultureIgnoreCase))
-					{
-						nomeFileSmall = nomeFileSmall.Substring(0, nomeFileSmall.Length - 4) + _picSettings.Codice +
-										nomeFileSmall.Substring(nomeFileSmall.Length - 4);
-					}
-
-					if (_picSettings.UsaOrarioMiniatura ||
-						_picSettings.TestoMin ||
-						_picSettings.AggTempoGaraMin ||
-						_picSettings.AggNumTempMin)
-					{
-						if (!string.IsNullOrWhiteSpace(testoFirmaPiccola))
-						{
-							Bitmap imgOutputSmall = (Bitmap)imgOutputBig.Clone();
-
-							Graphics grPhoto1 = Graphics.FromImage(imgOutputSmall);
-							grPhoto1.SmoothingMode = SmoothingMode.HighSpeed; //Todo: permettere di cambiare questo parametro
-
-							int larghezzaStandard1;
-
-							_dimensioneStandardMiniatura = 50;
-							bool grassetto = _picSettings.Grassetto;
-							crFont1 = new Font(_picSettings.IlFont, _dimensioneStandardMiniatura, grassetto ? FontStyle.Bold : FontStyle.Regular);
-							crFont2 = new Font(_picSettings.IlFont, _dimensioneStandard, grassetto ? FontStyle.Bold : FontStyle.Regular);
-
-							crSize1 = grPhoto1.MeasureString(testoFirmaPiccola, crFont1);
-							crSize2 = grPhoto1.MeasureString(testoFirma, crFont1);
-
-							larghezzaStandard1 = (int)crSize1.Width;
-
-							if (crSize1.Width > g.Width)
-							{
-								int conta = _dimensioneStandardMiniatura;
-								do
-								{
-									if (conta > 20)
-									{
-										conta -= 5;
-									}
-									else
-									{
-										conta -= 1;
-									}
-
-									crFont1 = new Font(_picSettings.IlFont, conta, grassetto ? FontStyle.Bold : FontStyle.Regular);
-									crSize1 = grPhoto1.MeasureString(testoFirmaPiccola, crFont1);
-
-									if (crSize1.Width < g.Width)
-									{
-										larghezzaStandard1 = (int)crSize1.Width;
-										break;
-									}
-
-								} while (conta > 5);
-								_dimensioneStandardMiniatura = conta;
-
-							}
-
-							switch (_picSettings.TextPosition.ToString().ToUpper())
-							{
-								case "ALTO":
-									yPosFromBottom1 = _picSettings.Margine;
-									yPosFromBottom4 = _picSettings.MargVert;
-									break;
-
-								case "BASSO":
-									yPosFromBottom1 =
-										(float)
-											(g.Height - crSize1.Height - (g.Height * CatalogVbLib.PicSettings.Margine / 100));
-									yPosFromBottom4 = (float)(g.Height - crSize1.Height - (g.Height * CatalogVbLib.PicSettings.MargVert / 100));
-									break;
-							}
-
-
-							float xCenterOfImg1 = Single.NaN;
-
-							StringFormat strFormat1 = new StringFormat();
-
-							switch (_picSettings.Allineamento.ToUpper())
-							{
-								case "SINISTRA":
-									xCenterOfImg1 = CatalogVbLib.PicSettings.Margine + (larghezzaStandard1 / 2);
-									if ((larghezzaStandard1 / 2) > (g.Width / 2) - CatalogVbLib.PicSettings.Margine)
-									{
-										xCenterOfImg1 = g.Width / 2;
-									}
-									break;
-
-								case "CENTRO":
-									xCenterOfImg1 = (g.Width / 2);
-									break;
-
-								case "DESTRA":
-									xCenterOfImg1 = (g.Width - CatalogVbLib.PicSettings.Margine - (larghezzaStandard1 / 2));
-									if ((larghezzaStandard1 / 2) > (g.Width / 2) - CatalogVbLib.PicSettings.Margine)
-									{
-										xCenterOfImg1 = g.Width / 2;
-									}
-									break;
-
-							}
-
-							strFormat1.Alignment = StringAlignment.Center;
-
-							SolidBrush semiTransBrush21 = new SolidBrush(Color.FromArgb(alphaScelta, 0, 0, 0));
-							SolidBrush semiTransBrush1 = new SolidBrush(Color.FromArgb(alphaScelta, CatalogVbLib.PicSettings.fontColoreRGB));
-
-							_dimensioneStandardMiniatura = CatalogVbLib.PicSettings.DimMin;
-
-							if (_picSettings.Grassetto)
-							{
-								crFont1 = new Font(_picSettings.IlFont, _dimensioneStandardMiniatura, FontStyle.Bold);
-							}
-							else
-							{
-								crFont1 = new Font(_picSettings.IlFont, _dimensioneStandardMiniatura);
-							}
-
-							if (_picSettings.TestoMin)
-							{
-								grPhoto1.DrawString(nomeFileBig, crFont1, semiTransBrush21, new PointF(xCenterOfImg1 + 1, yPosFromBottom1 + 1), strFormat1);
-								grPhoto1.DrawString(nomeFileBig, crFont1, semiTransBrush1, new PointF(xCenterOfImg1, yPosFromBottom1), strFormat1);
-							}
-							else if (_picSettings.AggTempoGaraMin & _picSettings.UsaTempoGaraTestoApplicare)
-							{
-								//TimeSpan orario = (dataPartenzaI - dataFoto) * 10000000; //todo
-								TimeSpan orario = dataPartenzaI - dataFoto; //todo controllare se torna la roba giusta
-
-								string tempStr = "";
-
-
-
-								tempStr += Environment.NewLine + testoOrario + orario.Hours.ToString("00") + ":" +
-										   orario.Minutes.ToString("00") + ":" + orario.Seconds.ToString("00"); //todo: usare una stringa formato per sta boiata
-
-								grPhoto1.DrawString(tempStr, crFont1, semiTransBrush21, new PointF(xCenterOfImg1 + 1, yPosFromBottom1 + 1));
-								grPhoto1.DrawString(tempStr, crFont1, semiTransBrush1, new PointF(xCenterOfImg1, yPosFromBottom1), strFormat1);
-							}
-							else if (_picSettings.AggNumTempMin) //todo semplificare la logica di sti eif
-							{
-								TimeSpan orario = dataPartenzaI - dataFoto; //todo controllare se torna la roba giusta
-								string tempStr = "";
-								tempStr += nomeFileBig + Environment.NewLine + testoOrario + orario.Hours.ToString("00") + ":" +
-										   orario.Minutes.ToString("00") + ":" + orario.Seconds.ToString("00"); //todo: usare una stringa formato per sta boiata
-
-								grPhoto1.DrawString(tempStr, crFont1, semiTransBrush21, new PointF(xCenterOfImg1 + 1, yPosFromBottom1 + 1));
-								grPhoto1.DrawString(tempStr, crFont1, semiTransBrush1, new PointF(xCenterOfImg1, yPosFromBottom1), strFormat1);
-							}
-							else
-							{
-								grPhoto1.DrawString(testoFirmaPiccola, crFont1, semiTransBrush21, new PointF(xCenterOfImg1 + 1, yPosFromBottom1 + 1), strFormat1);
-								grPhoto1.DrawString(testoFirmaPiccola, crFont1, semiTransBrush1, new PointF(xCenterOfImg1, yPosFromBottom1), strFormat1);
-							}
-
-
-							//Salva miniatura
-							
-							imgOutputSmall.Save(Path.Combine(DestDir.FullName, "Temp_" + nomeFileSmall), thisFormat);
-							float width = 0;
-							float height = 0;
-							//float scale = Math.Min(width/imgOutputSmall.Width, height/imgOutputSmall.Height);
-							using (var bmp = new Bitmap(thumbSizeSmall.Width, thumbSizeSmall.Height))
-							{
-								using (var graph = Graphics.FromImage(bmp))
-								{
-									// uncomment for higher quality output
-									//graph.InterpolationMode = InterpolationMode.High;
-									//graph.CompositingQuality = CompositingQuality.HighQuality;
-									//graph.SmoothingMode = SmoothingMode.AntiAlias;
-
-									graph.DrawImage(imgOutputSmall, new Rectangle(0, 0, (int)width, (int)height));
-
-									bmp.Save(Path.Combine(DestDir.FullName, nomeFileSmall), thisFormat);
-								}
-							}
-							//var bmp = new Bitmap(thumbSizeSmall.Width, thumbSizeSmall.Height);
-							//var graph = Graphics.FromImage(bmp);
-
-
-
-//                             10 down vote accepted
-	
-
-//Target parameters:
-
-//float width = 1024;
-//float height = 768;
-//var brush = new SolidBrush(Color.Black);
-
-//Your original file:
-
-//var image = new Bitmap(file);
-
-//Target sizing (scale factor):
-
-//float scale = Math.Min(width / image.Width, height / image.Height);
-
-//The resize including brushing canvas first:
-
-//var bmp = new Bitmap((int)width, (int)height);
-//var graph = Graphics.FromImage(bmp);
-
-//// uncomment for higher quality output
-////graph.InterpolationMode = InterpolationMode.High;
-////graph.CompositingQuality = CompositingQuality.HighQuality;
-////graph.SmoothingMode = SmoothingMode.AntiAlias;
-
-//var scaleWidth = (int)(image.Width * scale);
-//var scaleHeight = (int)(image.Height * scale);
-
-//graph.FillRectangle(brush, new RectangleF(0, 0, width, height));
-//graph.DrawImage(image, new Rectangle(((int)width - scaleWidth)/2, ((int)height - scaleHeight)/2, scaleWidth, scaleHeight));
-
-
-
-							//imgOutputSmall.Save(Path.Combine(DestDir.FullName, nomeFileSmall), thisFormat);
-
-
-							//Image g2 = Image.FromFile(Path.Combine(DestDir.FullName, "Temp_" + nomeFileSmall));
-							//Bitmap imgOutputSmall2 = new Bitmap(g2, thumbSizeSmall.Width, thumbSizeSmall.Height);
-							//imgOutputSmall2.Save(Path.Combine(DestDir.FullName, nomeFileSmall), thisFormat);
-
-
-
-						}
-					}
-
-
-				}
-			}
-
-
-
-		}
-
-
-
-		/// <summary>
-		/// Calculate the Size of the New image
-		/// </summary>
-		/// <param name="currentwidth">Larghezza</param>
-		/// <param name="currentheight">Altezza</param>
-		/// <param name="MaxPixel"></param>
-		/// <param name="TipoSize"></param>
-		/// <returns></returns>
-		/// <remarks></remarks>
-		private Size NewthumbSize(int currentwidth, int currentheight, int MaxPixel, string TipoSize)
-		{
-			// e  
-			//*** Larghezza, Altezza, Auto
-
-			double tempMultiplier = 0;
-
-			if (TipoSize.ToUpper() == "Larghezza".ToUpper())
-			{
-				tempMultiplier = MaxPixel / currentwidth;
-			}
-			else if (TipoSize.ToUpper() == "Altezza".ToUpper())
-			{
-				tempMultiplier = MaxPixel / currentheight;
-			}
-			else
-			{
-				// portrait  
-				if (currentheight > currentwidth)
-				{
-					tempMultiplier = MaxPixel / currentheight;
-				}
-				else
-				{
-					tempMultiplier = MaxPixel / currentwidth;
-				}
-			}
-
-			Size NewSize = new Size(Convert.ToInt32(currentwidth * tempMultiplier), Convert.ToInt32(currentheight * tempMultiplier));
-
-			return NewSize;
-		}
-	}
-}

CatalogLib/ImageCreator2.cs

@@ -1,166 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Drawing;
-using System.Drawing.Imaging;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using CatalogVbLib;
-
-namespace CatalogLib
-{
-    public class ImageCreator2 : IImageProcessor
-    {
-        private PicSettings _picSettings = PicSettings.Instance;
-
-        private FileInfo _workFile;
-
-        private Image _workingImage;
-
-        private Rotazione _rotation;
-
-        private ImageFormat _currentFormat;
-
-        private Size _newImageSize;
-
-        private Bitmap _outputImage;
-
-        private DirectoryInfo _destDir;
-
-        private string _nomeFileBig;
-
-        public void Start(FileInfo workFile)
-        {
-            _workFile = workFile;
-
-            _workingImage = Image.FromFile(workFile.FullName);
-
-            _destDir = new DirectoryInfo(_picSettings.DirectoryDestinazione);
-            _nomeFileBig = _workFile.Name;
-
-            CalculateImageSize();
-
-            ElaborazioneTesto();
-
-            ElaborazioneRotazione();
-
-            SetImageFormat();
-
-
-            FinalElaboration();
-
-            //CreaMiniature
-        }
-
-        private void FinalElaboration()
-        {
-            _outputImage = new Bitmap(_workingImage, _newImageSize.Width, _newImageSize.Height);
-            _outputImage.SetResolution(_workingImage.HorizontalResolution, _workingImage.VerticalResolution);
-
-
-            SavePic(_outputImage, Path.Combine(_destDir.FullName, _nomeFileBig));
-        }
-
-        private void SavePic(Bitmap imageToSave, string fileName)
-        {
-            var selectedEncoder = GetEncoder(_currentFormat);
-            var encoder = System.Drawing.Imaging.Encoder.Quality;
-            var encoderParameters = new EncoderParameters(1);
-
-            
-            if (Equals(_currentFormat, ImageFormat.Jpeg))
-            {
-                var encoderParameter = new EncoderParameter(encoder, _picSettings.CompressioneJpeg);
-                encoderParameters.Param[0] = encoderParameter;
-            }
-
-            imageToSave.Save(fileName, selectedEncoder,encoderParameters);
-            imageToSave.Dispose();
-        }
-
-        private ImageCodecInfo GetEncoder(ImageFormat format)
-        {
-            var codecs = ImageCodecInfo.GetImageDecoders();
-
-            return codecs.FirstOrDefault(c => c.FormatID == format.Guid);
-        }
-
-        private void ElaborazioneTesto()
-        {
-            if (_picSettings.EnableText)
-            {
-                // todo: elaborazione testo
-            }
-        }
-
-        private void CalculateImageSize()
-        {
-            _newImageSize = new Size(_workingImage.Width, _workingImage.Height);
-        }
-
-        private void ElaborazioneRotazione()
-        {
-            
-            _rotation = Rotazione.Normale;
-
-            if (_picSettings.GeneraleRotazioneAutomatica)
-            {
-                // ci sono dati exif
-                if (_workingImage.PropertyIdList.Length > 0)
-                {
-                    ExifReader DatiExif = new ExifReader((Bitmap)_workingImage);
-
-                    switch (DatiExif.Orientation)
-                    {
-                        case ExifReader.Orientations.BottomLeft:
-
-                            break;
-                        case ExifReader.Orientations.BottomRight:
-
-                            break;
-                        case ExifReader.Orientations.LeftTop:
-
-                            break;
-                        case ExifReader.Orientations.LftBottom:
-                            //FotoRuotaASinistra = true;
-                            _rotation = Rotazione.Sinistra;
-                            break;
-                        case ExifReader.Orientations.RightBottom:
-
-                            break;
-                        case ExifReader.Orientations.RightTop:
-
-                            break;
-                        case ExifReader.Orientations.TopLeft:
-
-                            break;
-                        case ExifReader.Orientations.TopRight:
-
-                            break;
-                    }
-                }
-            }
-
-            if (_rotation == Rotazione.Sinistra)
-            {
-                _workingImage.RotateFlip(RotateFlipType.Rotate270FlipNone);
-            }
-            else
-            if (_rotation == Rotazione.Destra)
-            {
-                _workingImage.RotateFlip(RotateFlipType.Rotate90FlipNone);
-            }
-        }
-
-        private void SetImageFormat()
-        {
-            _currentFormat = _workingImage.RawFormat;
-            if (_picSettings.GeneraleForzaJPG)
-            {
-                _currentFormat = ImageFormat.Jpeg;
-            }
-        }
-
-    }
-}

CatalogLib/ImgSharpCreator.cs

@@ -1,549 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
-using System.Numerics;
-using System.Threading.Tasks;
-using MaddoLibrary.Base.Log;
-using SixLabors.Fonts;
-using SixLabors.ImageSharp;
-using SixLabors.ImageSharp.Drawing;
-using SixLabors.ImageSharp.Formats.Jpeg;
-using SixLabors.ImageSharp.MetaData.Profiles.Exif;
-using SixLabors.ImageSharp.Processing;
-using SixLabors.Primitives;
-using Font = SixLabors.Fonts.Font;
-using FontFamily = SixLabors.Fonts.FontFamily;
-using FontStyle = SixLabors.Fonts.FontStyle;
-using Rgba32 = SixLabors.ImageSharp.Rgba32;
-using Image = SixLabors.ImageSharp.Image;
-
-namespace CatalogLib
-{
-    public class ImgSharpCreator : IImageProcessor
-    {
-        private Image<Rgba32> _logo;
-        public ImgSharpCreator()
-        {
-            if (!PicSettings.Instance.EnableLogo) return;
-            if (string.IsNullOrWhiteSpace(PicSettings.Instance.LogoPath)) return;
-            if (!File.Exists(PicSettings.Instance.LogoPath)) return;
-
-            _logo = Image.Load(PicSettings.Instance.LogoPath);
-
-        }
-        private FileInfo _currentFile;
-        public void Start(FileInfo workFile)
-        {
-
-            Stopwatch s = new Stopwatch();
-            s.Start();
-
-            _currentFile = workFile;
-
-
-
-            using (Image<Rgba32> image = Image.Load(workFile.FullName)/* new Image(workFile.FullName)*/)
-            {
-                MaddoLogger.Log("Loaded Image: {0}", workFile.FullName);
-                //image.Rotate(-90);
-                bool isRotated;
-
-                var orientation = image.MetaData.ExifProfile.GetValue(ExifTag.Orientation);
-                if ((ushort)orientation.Value != 1)
-                {
-                    isRotated = true;
-                }
-                else
-                {
-                    isRotated = false;
-                }
-
-                if (PicSettings.Instance.FotoRidimensiona)
-                {
-                    Resize(image);
-                }
-
-
-                if (PicSettings.Instance.GeneraleRotazioneAutomatica)
-                {
-                    image.Mutate(img => img.AutoOrient());
-                    MaddoLogger.Log("Rotated Image: {0}", workFile.FullName);
-                    //image.AutoOrient();
-
-                    //var exif = image.MetaData.ExifProfile;
-                    //if (exif != null)
-                    //{
-                    //    var o = exif.GetValue(ExifTag.Orientation);
-                    //    if (o != null)
-                    //    {
-                    //        var v = (ushort)o.Value;
-
-
-
-                    //        switch (v)
-                    //        {
-
-
-                    //            //1 = Horizontal(normal)
-                    //            //2 = Mirror horizontal
-                    //            //3 = Rotate 180
-                    //            //4 = Mirror vertical
-                    //            //5 = Mirror horizontal and rotate 270 CW
-                    //            //6 = Rotate 90 CW
-                    //            //7 = Mirror horizontal and rotate 90 CW
-                    //            //8 = Rotate 270 CW
-                    //            case 1:
-                    //                break;
-                    //            case 2:
-                    //                image.Flip(FlipType.Horizontal);
-                    //                break;
-                    //            case 3:
-                    //                //image.Rotate(180f);
-
-                    //                //image.Rotate(90);
-                    //                image.Rotate(RotateType.Rotate180);
-                    //                break;
-                    //            case 4:
-                    //                image.Flip(FlipType.Vertical);
-                    //                break;
-                    //            case 5:
-                    //                image.RotateFlip(RotateType.Rotate270, FlipType.Horizontal);
-                    //                break;
-                    //            case 6:
-                    //                image.Rotate(RotateType.Rotate90);
-                    //                break;
-                    //            case 7:
-                    //                image.RotateFlip(RotateType.Rotate90, FlipType.Horizontal);
-                    //                break;
-                    //            case 8:
-                    //                //image.Rotate(-90);
-                    //                image.Rotate(RotateType.Rotate270);
-
-                    //                image.MetaData.ExifProfile.SetValue(ExifTag.Orientation, new ExifValue(exif.GetValue(ExifTag.Orientation)).Value = (ushort)1);
-                    //                break;
-
-
-                    //        }
-                    //    }
-                    //}
-
-                }
-
-                if (PicSettings.Instance.EnableText)
-                {
-                    //SetTextTest(image);
-                    SetExtraText(image, isRotated);
-
-
-                    MaddoLogger.Log("Drawn text on Image: {0}", workFile.FullName);
-                }
-
-                //JpegDecoder j = new JpegDecoder();
-                var va = Vector.IsHardwareAccelerated;
-
-                MaddoLogger.Log("Hardware Accelerated: {0}", va);
-                //image.Resize(PicSettings.Instance.FotoLarghezza, PicSettings.Instance.FotoAltezza);
-
-                //image.Resize(2240, 2240);
-                //var fff = FontCollection.SystemFonts.Find(PicSettings.Instance.NomeFont);
-                //var font = new Font(fff, (float)PicSettings.Instance.DimensioneFont, FontStyle.Regular);
-                //image.DrawText("sssssssssssssssssssssssssssssssssssssssssssssss", font, Color.Black, new Vector2(200, 200));
-                image.Save(Path.Combine(PicSettings.Instance.DirectoryDestinazione, workFile.Name), new JpegEncoder() { Quality = PicSettings.Instance.CompressioneJpeg });
-                //image.Resize(200, 200).Save("");
-
-                MaddoLogger.Log("Saved Image: {0} to: {1}", workFile.FullName, Path.Combine(PicSettings.Instance.DirectoryDestinazione, workFile.Name));
-            }
-            s.Stop();
-            MaddoLogger.Log("Time Taken for {0}: {1}", workFile.FullName, s.Elapsed);
-        }
-
-        private void Resize(Image<Rgba32> image)
-        {
-            IResampler resampler;
-            switch (PicSettings.Instance.ResizeMode)
-            {
-                case ResizeModes.Bicubic:
-                    resampler = new BicubicResampler();
-                    break;
-                case ResizeModes.Box:
-                    resampler = new BoxResampler();
-                    break;
-                case ResizeModes.CatmullRom:
-                    resampler = new CatmullRomResampler();
-                    break;
-                case ResizeModes.Hermite:
-                    resampler = new HermiteResampler();
-                    break;
-                case ResizeModes.Lanczos2:
-                    resampler = new Lanczos2Resampler();
-                    break;
-                case ResizeModes.Lanczos3:
-                    resampler = new Lanczos3Resampler();
-                    break;
-                case ResizeModes.Lanczos5:
-                    resampler = new Lanczos5Resampler();
-                    break;
-                case ResizeModes.Lanczos8:
-                    resampler = new Lanczos8Resampler();
-                    break;
-                case ResizeModes.MitchellNetravali:
-                    resampler = new MitchellNetravaliResampler();
-                    break;
-                case ResizeModes.NearestNeighbor:
-                    resampler = new NearestNeighborResampler();
-                    break;
-                case ResizeModes.Robidoux:
-                    resampler = new RobidouxResampler();
-                    break;
-                case ResizeModes.Spline:
-                    resampler = new SplineResampler();
-                    break;
-                case ResizeModes.Triangle:
-                    resampler = new TriangleResampler();
-                    break;
-                case ResizeModes.Welch:
-                    resampler = new WelchResampler();
-                    break;
-                default:
-                    throw new ArgumentOutOfRangeException();
-            }
-            // todo calcolare ridimensionamento
-            var size = new Size(PicSettings.Instance.FotoLarghezza, PicSettings.Instance.FotoAltezza);
-            if (PicSettings.Instance.FotoMantieniDimensioni)
-            {
-                size = ResizeImage(image, size, PicSettings.Instance.ResizeDimension);
-                image.Mutate(x => x.Resize((size.Width), (size.Height), resampler));
-
-                //Width Formula:
-                //original height / original width * new width = new height
-                //Height Formula:
-                //orignal width / orignal height * new height = new width
-            }
-            else
-            {
-
-                image.Mutate(x => x.Resize(PicSettings.Instance.FotoAltezza, PicSettings.Instance.FotoLarghezza, resampler));
-            }
-
-        }
-
-        private Size ResizeImage(Image<Rgba32> image, Size size, ResizeDimensions side)
-        {
-            switch (side)
-            {
-                case ResizeDimensions.LatoLungo:
-                    size = GetResizeDimensions(new Size(image.Width, image.Height), size, image.Width > image.Height);
-                    break;
-                case ResizeDimensions.LatoCorto:
-                    size = GetResizeDimensions(new Size(image.Width, image.Height), size, image.Width <= image.Height);
-                    break;
-                default:
-                    throw new ArgumentOutOfRangeException();
-            }
-            return size;
-        }
-
-        private Size GetResizeDimensions(Size originalSize, Size newSize, bool adjustHeight)
-        {
-            return adjustHeight ? new Size(newSize.Width, originalSize.Height / originalSize.Width * newSize.Height) : new Size(originalSize.Width / originalSize.Height * newSize.Height, newSize.Height);
-        }
-
-        private void SetTextTest(Image<Rgba32> image)
-        {
-            string text = "test test test test test testtest test test test test test test";
-            Font font = new Font(SystemFonts.Find("verdana"), 300, FontStyle.Regular);
-            image.Mutate(x => x.DrawText(text, font, Rgba32.Yellow, new PointF(2760, 3295.54932f), new TextGraphicsOptions()
-            {
-                HorizontalAlignment = HorizontalAlignment.Center
-            }));
-        }
-
-        private void SetExtraText(Image<Rgba32> image, bool isRotated)
-        {
-            if (string.IsNullOrWhiteSpace(PicSettings.Instance.TestoApplicareOrizzontale))
-            {
-                Debug.WriteLine($"{_currentFile.Name} No text");
-                return;
-            }
-
-            string text;
-            if (isRotated)
-            {
-                if (PicSettings.Instance.TestoApplicareOrizzontale.Contains("$_"))
-                {
-                    text = PicSettings.Instance.TestoApplicareOrizzontale.Replace("$_", "\r\n");
-                }
-                else
-                {
-                    text = PicSettings.Instance.TestoApplicareOrizzontale.Replace("$_", "");
-                }
-
-            }
-            else
-            {
-                text = PicSettings.Instance.TestoApplicareOrizzontale.Replace("$_", "");
-            }
-
-
-            var fo = SixLabors.Fonts.SystemFonts.Find(PicSettings.Instance.NomeFont);
-
-
-            //var fff = FontCollection.SystemFonts.Find(PicSettings.Instance.NomeFont);
-            //var fff = FontCollection.SystemFonts.Find("Segoe Print");
-
-            Font font;
-
-            if (!PicSettings.Instance.Grassetto)
-            {
-                font = new Font(fo, (float)PicSettings.Instance.DimensioneFont, FontStyle.Regular);
-            }
-            else
-            {
-                font = new Font(fo, (float)PicSettings.Instance.DimensioneFont, FontStyle.Bold);
-            }
-            // todo corsivo
-
-
-
-            //var font = new Font(fff, 8f, FontStyle.Regular);
-
-
-            //Color c = Color.FromHex(FlipRgbString(PicSettings.Instance.ColoreTestoRGB));
-            Rgba32 g = Rgba32.FromHex(FlipRgbString(PicSettings.Instance.ColoreTestoRGB));
-
-            Rgba32 gBack = Rgba32.Black; // todo alpha
-            //TextMeasurer measurer = new TextMeasurer();
-
-            //var size = measurer.MeasureText(PicSettings.Instance.TestoApplicareOrizzontale, font, 72);
-            //float scalingFactor = Math.Min(image.Width / size.Width, image.Height / size.Height);
-            //Font scaledFont = new Font(font, scalingFactor * font.Size);
-
-            //image.DrawText(PicSettings.Instance.TestoApplicareOrizzontale, scaledFont, g, new Vector2(0, 0));
-
-            Vector2 center = new Vector2(image.Width / 2, image.Height / 2); //center horizontally, 10px down 
-
-            var size = TextMeasurer.Measure(text, new RendererOptions(font));
-
-            var larghezzaStandard = size.Width;
-            var dimensioneStandard = (int)Math.Round(PicSettings.Instance.DimensioneFont);
-            if (size.Width > image.Width)
-            {
-                var c = dimensioneStandard;
-                do
-                {
-                    if (c > 20)
-                    {
-                        c -= 5;
-                    }
-                    else
-                    {
-                        c -= 1;
-                    }
-
-                    if (PicSettings.Instance.Grassetto)
-                    {
-                        font = new Font(fo, c, FontStyle.Bold);
-                    }
-                    else
-                    {
-                        font = new Font(fo, c, FontStyle.Regular);
-                    }
-                    size = TextMeasurer.Measure(text,
-                        new RendererOptions(font));
-                    if (size.Width < image.Width)
-                    {
-                        larghezzaStandard = (int)Math.Round(size.Width);
-                        break;
-                    }
-                    if (c <= 5)
-                    {
-                        break;
-                    }
-                } while (dimensioneStandard == c);
-            }
-
-            float yPosFromBottom = 0;
-
-            switch (PicSettings.Instance.TextPosition)
-            {
-                case Positions.Alto:
-                    yPosFromBottom = PicSettings.Instance.Margine;
-                    break;
-                case Positions.Basso:
-                    yPosFromBottom = image.Height - size.Height - (image.Height * PicSettings.Instance.Margine / 100);
-                    break;
-            }
-
-            float xCenterofImg = 0;
-
-            // stringformat
-
-            switch (PicSettings.Instance.TextAlignment)
-            {
-                case Alignments.Sinistra:
-                    xCenterofImg = PicSettings.Instance.Margine + (larghezzaStandard / 2);
-                    if ((larghezzaStandard / 2) > (image.Width / 2) - PicSettings.Instance.Margine)
-                    {
-                        xCenterofImg = image.Width / 2;
-                    }
-                    break;
-                case Alignments.Centro:
-                    xCenterofImg = image.Width / 2;
-                    break;
-                case Alignments.Destra:
-                    xCenterofImg = image.Width - PicSettings.Instance.Margine - larghezzaStandard / 2;
-
-                    if (larghezzaStandard / 2 > image.Width / 2 - PicSettings.Instance.Margine)
-                    {
-                        xCenterofImg = image.Width / 2;
-                    }
-
-                    break;
-            }
-            // stringformat alignment center
-
-            if (PicSettings.Instance.Grassetto)
-            {
-                font = new Font(fo, dimensioneStandard, FontStyle.Bold);
-            }
-            else
-            {
-                font = new Font(fo, dimensioneStandard, FontStyle.Regular);
-            }
-
-            image.Mutate(x => x.DrawText(text, font, gBack, new PointF((float)Math.Round(xCenterofImg + 1), (float)Math.Round(yPosFromBottom + 1)), new TextGraphicsOptions()
-            {
-                HorizontalAlignment = HorizontalAlignment.Center
-            }));
-
-            image.Mutate(x => x.DrawText(text, font, g, new PointF((float)Math.Round(xCenterofImg), (float)Math.Round(yPosFromBottom)), new TextGraphicsOptions()
-            {
-                HorizontalAlignment = HorizontalAlignment.Center
-            }));
-
-            return;
-
-
-            float scalingFactor = Math.Min(image.Width / size.Width, image.Height / size.Height);
-            Font scaledFont = new Font(font, scalingFactor * font.Size);
-
-            image.Mutate(x =>
-            x.DrawText(PicSettings.Instance.TestoApplicareOrizzontale, scaledFont, g, center,
-            new TextGraphicsOptions(true)
-            {
-                HorizontalAlignment = HorizontalAlignment.Center,
-                VerticalAlignment = VerticalAlignment.Bottom
-            }));
-            //image.DrawText(PicSettings.Instance.TestoApplicareOrizzontale, scaledFont, g, center, new TextGraphicsOptions(true) { HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Bottom });
-
-
-        }
-
-        private void AddLogo(Image<Rgba32> image)
-        {
-            //if (string.IsNullOrWhiteSpace(PicSettings.Instance.LogoPath)) return;
-            //if (!File.Exists(PicSettings.Instance.LogoPath)) return;
-            //using (Image<Rgba32> logo = Image.Load(PicSettings.Instance.LogoPath))
-            //{
-            //    Size size = new Size();
-            //    Point location = new Point();
-            //    image.Mutate(x => x.DrawImage(logo, size, location, new GraphicsOptions()
-            //    {
-
-            //    }));
-
-            //}
-
-            Size size = new Size();
-            Point location = new Point();
-
-            if (_logo != null)
-            {
-                var width = PicSettings.Instance.LogoWidth;
-                var height = PicSettings.Instance.LogoHeight;
-                var heightFactor = _logo.Height / height;
-                var widthFactor = _logo.Width / width;
-                var newLogoSize = new Size();
-
-                newLogoSize = GetResizeDimensions(new Size(_logo.Width, _logo.Height), new Size(width, height), PicSettings.Instance.LogoResizeSide.Equals(ResizeDimensions.LatoCorto));
-                //todo riguardare perché non torna cosa ho fatto
-
-                int margineUsato = 0;
-                int margineL;
-                bool inPercentualeL;
-
-                inPercentualeL = PicSettings.Instance.LogoMargin.EndsWith("%");
-                if (inPercentualeL)
-                {
-                    margineL = int.Parse(PicSettings.Instance.LogoMargin.Replace("%", ""));
-                }
-                else
-                {
-                    margineL = int.Parse(PicSettings.Instance.LogoMargin);
-                }
-
-                switch (PicSettings.Instance.LogoPosition)
-                {
-                    case Positions.Alto:
-                        break;
-                    case Positions.Centro:
-                        break;
-                    case Positions.Basso:
-                        break;
-                    default:
-                        throw new ArgumentOutOfRangeException();
-                }
-
-                switch (PicSettings.Instance.LogoAlignment)
-                {
-                    case Alignments.Sinistra:
-                        location.X = margineUsato;
-                        break;
-                    case Alignments.Centro:
-                        //location.X = image.Width - 
-                        break;
-                    case Alignments.Destra:
-                        break;
-                    default:
-                        throw new ArgumentOutOfRangeException();
-                }
-                image.Mutate(x => x.DrawImage(_logo, size, location, new GraphicsOptions()));
-
-
-
-
-            }
-
-        }
-
-        private void WriteTextFixed(Image<Rgba32> image)
-        {
-            var fo = SixLabors.Fonts.SystemFonts.Find("Microsoft Sans Serif");
-            var font = new Font(fo, 8, FontStyle.Regular);
-            Rgba32 g = Rgba32.FromHex("#FF00FFFF");
-            Vector2 center = new Vector2(image.Width / 2, image.Height / 2);
-            var size = TextMeasurer.Measure("Test test test test test", new RendererOptions(font));
-            float scalingFactor = Math.Min(image.Width / size.Width, image.Height / size.Height);
-            Font scaledFont = new Font(font, scalingFactor * font.Size);
-            image.Mutate(x => x.DrawText("Test test test test test", scaledFont, g, center, new TextGraphicsOptions(true) { HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Bottom }));
-        }
-
-        private string FlipRgbString(string originalString)
-        {
-            string s;
-            if (originalString.Length == 7)
-            {
-                s = string.Concat("#", originalString.Substring(1, 6));
-            }
-            else
-            {
-                s = string.Concat("#", originalString.Substring(3, 6), originalString.Substring(1, 2));
-            }
-
-
-            return s;
-        }
-    }
-}

CatalogLib/PicSettings.cs

@@ -1,548 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Drawing;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using MaddoLibrary.Base.Log;
-using Newtonsoft.Json;
-
-namespace CatalogLib
-{
-    public class PicSettings
-    {
-        private static PicSettings _instance = new PicSettings();
-
-        public static PicSettings Instance
-        {
-            get { return _instance; }
-        }
-
-        private Dictionary<string, object> _settingsDict = new Dictionary<string, object>();
-
-        public PicSettings()
-        {
-            SetDefaults();
-        }
-
-        public string SerializeSettings()
-        {
-            return JsonConvert.SerializeObject(_settingsDict);
-        }
-
-        public void DeserializeSettings(string serializedData)
-        {
-            _settingsDict = JsonConvert.DeserializeObject<Dictionary<string, object>>(serializedData);
-
-
-        }
-
-        public void SetBase(string key, object value)
-        {
-            if (_settingsDict.ContainsKey(key))
-            {
-                _settingsDict[key] = value;
-            }
-            else
-            {
-                _settingsDict.Add(key, value);
-            }
-        }
-
-        public void SetString(string key, string value)
-        {
-            SetBase(key, value);
-        }
-
-        public void SetInt(string key, int value)
-        {
-            SetBase(key, value);
-        }
-
-        public void SetBool(string key, bool value)
-        {
-            SetBase(key, value);
-        }
-
-        public void SetDouble(string key, double value)
-        {
-            SetBase(key, value);
-        }
-
-        public void SetFloat(string key, float value)
-        {
-            SetBase(key, value);
-        }
-
-        public void Set<T>(string key, T value)
-        {
-            SetBase(key, value);
-        }
-
-        public bool Exists(string key)
-        {
-            return _settingsDict.ContainsKey(key);
-        }
-
-        public int GetInt(string key, int defaultValue = 0)
-        {
-            if (!_settingsDict.ContainsKey(key))
-            {
-                SetInt(key, defaultValue);
-            }
-
-            if (_settingsDict[key] is int) return (int)_settingsDict[key];
-            Debug.WriteLine($"Error while parsing {key}");
-            //return defaultValue;
-
-            int r;
-
-            if (int.TryParse(_settingsDict[key].ToString(), out r))
-            {
-                SetInt(key, r);
-
-            }
-            else
-            {
-                SetInt(key, defaultValue);
-            }
-            return (int)_settingsDict[key];
-            //return (int) _settingsDict[key];
-
-            //return _settingsDict.ContainsKey(key) ? (int)_settingsDict[key] : defaultValue;
-        }
-
-        public double GetDouble(string key, double defaultValue = 0)
-        {
-            if (!_settingsDict.ContainsKey(key))
-            {
-                SetDouble(key, defaultValue);
-                // setdouble default
-            }
-
-            if (_settingsDict[key] is double) return (double)_settingsDict[key];
-            Debug.WriteLine($"Error while parsing {key}");
-
-            double d;
-            if (double.TryParse(_settingsDict[key].ToString(), out d))
-            {
-                SetDouble(key, d);
-                // setdouble key r
-            }
-            else
-            {
-                SetDouble(key, defaultValue);
-                //setdouble defaultvalue
-            }
-            return (double)_settingsDict[key];
-        }
-
-        public float GetFloat(string key, float defaultValue = 0)
-        {
-            if (!_settingsDict.ContainsKey(key))
-            {
-                SetFloat(key, defaultValue);
-            }
-
-            if (_settingsDict[key] is float f) return f;
-            MaddoLogger.LogError("Error while parsing {0}", key);
-
-            float fl = 0;
-            SetFloat(key, float.TryParse(_settingsDict[key].ToString(), out f) ? fl : defaultValue);
-            return (float)_settingsDict[key];
-        }
-
-
-
-        public T Get<T>(string key, T defaultValue)
-        {
-            if (!_settingsDict.ContainsKey(key))
-            {
-                Set<T>(key, defaultValue);
-                // setdouble default
-            }
-
-            return (T)_settingsDict[key];
-        }
-
-
-
-
-        public string GetString(string key, string defaultValue = "")
-        {
-            if (!_settingsDict.ContainsKey(key))
-            {
-                SetString(key, defaultValue);
-            }
-            return (string)_settingsDict[key];
-
-            //return _settingsDict.ContainsKey(key) ? (string)_settingsDict[key] : defaultValue;
-        }
-
-        public bool GetBool(string key, bool defaultValue = false)
-        {
-            if (!_settingsDict.ContainsKey(key))
-            {
-                SetBool(key, defaultValue);
-                return defaultValue;
-            }
-            return (bool)_settingsDict[key];
-
-
-
-            //return _settingsDict.ContainsKey(key) && (bool)_settingsDict[key];
-        }
-
-
-        public object GetObject(string key, object defaultValue = null)
-        {
-            if (!_settingsDict.ContainsKey(key))
-            {
-                Set(key, defaultValue);
-                return defaultValue;
-            }
-            return _settingsDict[key];
-
-            //return _settingsDict.ContainsKey(key) ? _settingsDict[key] : defaultValue;
-        }
-
-        public T GetEnum<T>(string name, T defaultValue)
-        {
-            return (T)Enum.Parse(typeof(T), GetString(name, defaultValue.ToString()));
-        }
-
-        public void SetDefaults()
-        {
-
-        }
-
-        public bool DirAggiornaSottoDirectory
-        {
-            get => this.GetBool("DirAggiornaSottoDirectory", true);
-            set => this.SetBool("DirAggiornaSottoDirectory", value);
-        }
-
-        public bool Grassetto
-        {
-            get { return GetBool("Grassetto"); }
-            set { SetBool("Grassetto", value); }
-        }
-
-        public string IlFont //todo
-        {
-            get { return GetString(""); }
-            set { }
-        }
-
-        public bool TestoMin //todo
-        {
-            get { return false; }
-            set { }
-        }
-
-        public bool AggTempoGaraMin //todo
-        {
-            get { return false; }
-            set { }
-        }
-
-        public bool UsaTempoGaraTestoApplicare //todo
-        {
-            get { return false; }
-            set { }
-        }
-
-        public bool AggNumTempMin //todo
-        {
-            get { return false; }
-            set { }
-        }
-
-        public bool CreaMiniature //todo
-        {
-            get { return false; }
-            set { }
-        }
-
-        public bool AggiungiScritteMiniature
-        {
-            get { return false; }
-            set { }
-        }
-
-        public string Suffisso
-        {
-            get { return string.Empty; }
-            set { }
-        }
-
-        public string Codice
-        {
-            get { return null; }
-            set { }
-        }
-
-        public int Trasparenza
-        {
-            get { return 0; }
-        }
-
-
-
-        public DateTime DataPartenza { get; set; }
-        public string TestoOrario { get; internal set; }
-        public int DimStandard { get; internal set; }
-        public int DimStandardMiniatura { get; internal set; }
-        public bool UsaOrarioTestoApplicare { get; set; }
-        public bool UsaOrarioMiniatura { get; set; }
-        public string TestoFirmaStart { get; set; }
-        public string TestoFirmaStartV { get; set; }
-        public bool UsaForzaJpg { get; set; }
-
-        public string DirectorySorgente
-        {
-            get { return GetString("DirSorgente"); }
-            set { SetString("DirSorgente", value); }
-        }
-
-        public string DirectoryDestinazione
-        {
-            get { return GetString("DirDestinazione"); }
-            set { SetString("DirDestinazione", value); }
-        }
-
-        public int Margine
-        {
-            get => GetInt("Margin", 1);
-            set => SetInt("Margin", value);
-        }
-        public float MargVert { get; set; }
-        public string Allineamento { get; set; }
-
-        public bool GeneraleForzaJPG
-        {
-            get { return GetBool("GeneraleForzaJPG", true); }
-            set { SetBool("GeneraleForzaJPG", value); }
-        }
-
-        public bool GeneraleRotazioneAutomatica
-        {
-            get { return GetBool("GeneraleRotazioneAutomatica", true); }
-            set { SetBool("GeneraleRotazioneAutomatica", value); }
-        }
-
-        public bool GeneraleSovrascriviFile
-        {
-            get { return GetBool("GeneraleSovrascriviFile"); }
-            set { SetBool("GeneraleSovrascriviFile", value); }
-        }
-
-        public bool SubdirCreaSottoCartelle
-        {
-            get { return GetBool("SubdirCreaSottoCartelle"); }
-            set { SetBool("SubdirCreaSottoCartelle", value); }
-        }
-
-        public int SubdirIntervalloFile
-        {
-            get { return GetInt("SubdirIntervalloFile", 99); }
-            set { SetInt("SubdirIntervalloFile", value); }
-        }
-
-        public string SubdirSuffisso
-        {
-            get { return GetString("SubdirSuffisso"); }
-            set { SetString("SubdirSuffisso", value); }
-        }
-
-        public int SubdirCifreContatore
-        {
-            get { return GetInt("SubdirCifreContatore", 2); }
-            set { SetInt("SubdirCifreContatore", value); }
-        }
-
-        public bool SubdirNumerazioneProgressiva
-        {
-            get { return GetBool("SubdirNumerazioneProgressiva", true); }
-            set { SetBool("SubdirNumerazioneProgressiva", value); }
-        }
-
-        public bool SubdirNumerazioneFiles
-        {
-            get { return GetBool("SubdirNumerazioneFiles", false); }
-            set { SetBool("SubdirNumerazioneFiles", value); }
-        }
-
-        public int FotoAltezza
-        {
-            get { return GetInt("FotoAltezza", 2240); }
-            set { SetInt("FotoAltezza", value); }
-        }
-
-        public int FotoLarghezza
-        {
-            get { return GetInt("FotoLarghezza", 2240); }
-            set { SetInt("FotoLarghezza", value); }
-        }
-
-        public int CompressioneJpeg
-        {
-            get { return GetInt("CompressioneJpeg", 85); }
-            set { SetInt("CompressioneJpeg", value); }
-        }
-
-        public bool FotoMantieniDimensioni
-        {
-            get { return GetBool("FotoMantieniDimensioni", true); }
-            set { SetBool("FotoMantieniDimensioni", value); }
-        }
-
-        public string FotoSuffisso
-        {
-            get { return GetString("FotoSuffisso"); }
-            set { SetString("FotoSuffisso", value); }
-        }
-
-
-        public bool EnableThumbnails
-        {
-            get { return GetBool("EnableThumbnails", false); }
-            set { SetBool("EnableThumbnails", value); }
-        }
-        public bool EnableLogo
-        {
-            get { return GetBool("EnableLogo", false); }
-            set { SetBool("EnableLogo", value); }
-        }
-
-        #region Text
-
-        public bool EnableText
-        {
-            get { return GetBool("EnableText", false); }
-            set { SetBool("EnableText", value); }
-        }
-
-        public string NomeFont
-        {
-            get { return GetString("nomeFont", "Verdana"); }
-            set { SetString("nomeFont", value); }
-        }
-
-        public double DimensioneFont
-        {
-            get { return Get<double>("dimensioneFont", 1); }
-            set { SetDouble("dimensioneFont", value); }
-        }
-
-        public string TestoApplicareOrizzontale
-        {
-            get
-            {
-                return Get<string>("TestoApplicareOrizzontale", "");
-            }
-            set
-            {
-                Set<string>("TestoApplicareOrizzontale", value);
-            }
-        }
-
-        public string ColoreTestoRGB
-        {
-            get { return GetString("coloreTestoRGB", "#000000"); }
-            set
-            {
-                Set("coloreTestoRGB", value);
-
-            }
-        }
-
-        public bool FotoRidimensiona
-        {
-            get => GetBool("FotoRidimensiona", false);
-            set => Set("FotoRidimensiona", value);
-        }
-
-        public Positions TextPosition
-        {
-            get => GetEnum("TextPosition", Positions.Alto); //(Positions)Enum.Parse(typeof(Positions), GetString("TextPosition", Positions.Alto.ToString()));
-            set => SetString("TextPosition", value.ToString());
-        }
-
-        public Alignments TextAlignment
-        {
-            get => GetEnum("TextAlignment", Alignments.Centro);
-            set => SetString("TextAlignment", value.ToString());
-        }
-
-        public bool Threading
-        {
-            get => GetBool("Threading", true);
-            set => SetBool("Threading", value);
-        }
-
-        public ResizeModes ResizeMode
-        {
-            get => GetEnum("ResizeMode", ResizeModes.Bicubic);
-            set => SetString("ResizeMode", value.ToString());
-        }
-
-        public ResizeDimensions ResizeDimension
-        {
-            get => GetEnum("ResizeDimension", CatalogLib.ResizeDimensions.LatoCorto);
-            set => SetString("ResizeDimension", value.ToString());
-        }
-
-        public string LogoPath
-        {
-            get => GetString("LogoPath");
-            set => SetString("LogoPath", value);
-        }
-
-        public int LogoWidth
-        {
-            get => GetInt("LogoWidth");
-            set => SetInt("LogoWidth", value);
-        }
-
-        public int LogoHeight
-        {
-            get => GetInt("LogoHeight");
-            set => SetInt("LogoHeight", value);
-        }
-
-        public string LogoMargin
-        {
-            get => GetString("LogoMargin");
-            set => SetString("LogoMargin", value);
-        }
-
-        public Positions LogoPosition
-        {
-            get => GetEnum("LogoPositions", Positions.Alto);
-            set => SetString("LogoPositions", value.ToString());
-        }
-
-        public Alignments LogoAlignment
-        {
-            get => GetEnum("LogoAlignments", Alignments.Centro);
-            set => SetString("LogoAlignments", value.ToString());
-        }
-
-        public ResizeDimensions LogoResizeSide
-        {
-            get => GetEnum("LogoResizeMode", ResizeDimensions.LatoCorto);
-            set => SetString("LogoResizeMode", value.ToString());
-        }
-
-        #endregion
-
-        #region Enums
-
-
-
-        #endregion
-    }
-}

CatalogLib/Properties/AssemblyInfo.cs

@@ -1,38 +0,0 @@
-using System;
-using System.Reflection;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-// General Information about an assembly is controlled through the following 
-// set of attributes. Change these attribute values to modify the information
-// associated with an assembly.
-[assembly: AssemblyTitle("CatalogLib")]
-[assembly: AssemblyDescription("")]
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("CatalogLib")]
-[assembly: AssemblyCopyright("Copyright ©  2013")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-
-// Setting ComVisible to false makes the types in this assembly not visible 
-// to COM components.  If you need to access a type in this assembly from 
-// COM, set the ComVisible attribute to true on that type.
-[assembly: ComVisible(false)]
-
-// The following GUID is for the ID of the typelib if this project is exposed to COM
-[assembly: Guid("7bb8e6ce-72c8-4b36-a166-a62ed446d4e9")]
-
-// Version information for an assembly consists of the following four values:
-//
-//      Major Version
-//      Minor Version 
-//      Build Number
-//      Revision
-//
-// You can specify all the values or you can default the Build and Revision Numbers 
-// by using the '*' as shown below:
-// [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
-[assembly: CLSCompliant(true)]

CatalogLib/SinglePicData.cs

@@ -1,22 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace CatalogLib
-{
-    public enum Rotazione
-    {
-        Normale,
-        Destra,
-        Sinistra,
-        Sottosopra
-    }
-
-    public class SinglePicData
-    {
-
-
-    }
-}

CatalogLib/app.config

@@ -1,35 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<configuration>
-  <runtime>
-    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
-      <dependentAssembly>
-        <assemblyIdentity name="System.Diagnostics.DiagnosticSource" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral"/>
-        <bindingRedirect oldVersion="0.0.0.0-4.0.1.0" newVersion="4.0.1.0"/>
-      </dependentAssembly>
-      <dependentAssembly>
-        <assemblyIdentity name="System.IO.FileSystem" publicKeyToken="b03f5f7f11d50a3a" culture="neutral"/>
-        <bindingRedirect oldVersion="0.0.0.0-4.0.2.0" newVersion="4.0.2.0"/>
-      </dependentAssembly>
-      <dependentAssembly>
-        <assemblyIdentity name="System.IO.Compression" publicKeyToken="b77a5c561934e089" culture="neutral"/>
-        <bindingRedirect oldVersion="0.0.0.0-4.1.2.0" newVersion="4.1.2.0"/>
-      </dependentAssembly>
-      <dependentAssembly>
-        <assemblyIdentity name="System.Numerics.Vectors" publicKeyToken="b03f5f7f11d50a3a" culture="neutral"/>
-        <bindingRedirect oldVersion="0.0.0.0-4.1.2.0" newVersion="4.1.2.0"/>
-      </dependentAssembly>
-      <dependentAssembly>
-        <assemblyIdentity name="System.Buffers" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral"/>
-        <bindingRedirect oldVersion="0.0.0.0-4.0.1.0" newVersion="4.0.1.0"/>
-      </dependentAssembly>
-      <dependentAssembly>
-        <assemblyIdentity name="System.Runtime.CompilerServices.Unsafe" publicKeyToken="b03f5f7f11d50a3a" culture="neutral"/>
-        <bindingRedirect oldVersion="0.0.0.0-4.0.2.0" newVersion="4.0.2.0"/>
-      </dependentAssembly>
-      <dependentAssembly>
-        <assemblyIdentity name="System.Security.Cryptography.Primitives" publicKeyToken="b03f5f7f11d50a3a" culture="neutral"/>
-        <bindingRedirect oldVersion="0.0.0.0-4.0.1.0" newVersion="4.0.1.0"/>
-      </dependentAssembly>
-    </assemblyBinding>
-  </runtime>
-<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.8"/></startup></configuration>

CatalogLib/packages.config

@@ -1,63 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="ImageSharp" version="1.0.0-alpha9-00169" targetFramework="net46" />
-  <package id="ImageSharp.Drawing" version="1.0.0-alpha9-00164" targetFramework="net46" />
-  <package id="Microsoft.NETCore.Platforms" version="1.1.0" targetFramework="net46" />
-  <package id="Microsoft.Win32.Primitives" version="4.3.0" targetFramework="net46" />
-  <package id="NETStandard.Library" version="1.6.1" targetFramework="net46" />
-  <package id="Newtonsoft.Json" version="9.0.1" targetFramework="net46" />
-  <package id="SixLabors.Core" version="0.1.0-alpha0002" targetFramework="net46" />
-  <package id="SixLabors.Fonts" version="0.1.0-alpha0014" targetFramework="net46" />
-  <package id="SixLabors.Shapes" version="0.1.0-alpha0018" targetFramework="net46" />
-  <package id="SixLabors.Shapes.Text" version="0.1.0-alpha0018" targetFramework="net46" />
-  <package id="System.AppContext" version="4.3.0" targetFramework="net46" requireReinstallation="true" />
-  <package id="System.Buffers" version="4.3.0" targetFramework="net46" />
-  <package id="System.Collections" version="4.3.0" targetFramework="net46" />
-  <package id="System.Collections.Concurrent" version="4.3.0" targetFramework="net46" />
-  <package id="System.Collections.Immutable" version="1.3.1" targetFramework="net46" />
-  <package id="System.Console" version="4.3.0" targetFramework="net46" />
-  <package id="System.Diagnostics.Debug" version="4.3.0" targetFramework="net46" />
-  <package id="System.Diagnostics.DiagnosticSource" version="4.3.0" targetFramework="net46" />
-  <package id="System.Diagnostics.Tools" version="4.3.0" targetFramework="net46" />
-  <package id="System.Diagnostics.Tracing" version="4.3.0" targetFramework="net46" requireReinstallation="true" />
-  <package id="System.Globalization" version="4.3.0" targetFramework="net46" />
-  <package id="System.Globalization.Calendars" version="4.3.0" targetFramework="net46" />
-  <package id="System.IO" version="4.3.0" targetFramework="net46" requireReinstallation="true" />
-  <package id="System.IO.Compression" version="4.3.0" targetFramework="net46" />
-  <package id="System.IO.Compression.ZipFile" version="4.3.0" targetFramework="net46" />
-  <package id="System.IO.FileSystem" version="4.3.0" targetFramework="net46" />
-  <package id="System.IO.FileSystem.Primitives" version="4.3.0" targetFramework="net46" />
-  <package id="System.Linq" version="4.3.0" targetFramework="net46" requireReinstallation="true" />
-  <package id="System.Linq.Expressions" version="4.3.0" targetFramework="net46" requireReinstallation="true" />
-  <package id="System.Memory" version="4.4.0-preview1-25305-02" targetFramework="net46" requireReinstallation="true" />
-  <package id="System.Net.Http" version="4.3.0" targetFramework="net46" />
-  <package id="System.Net.Primitives" version="4.3.0" targetFramework="net46" />
-  <package id="System.Net.Sockets" version="4.3.0" targetFramework="net46" />
-  <package id="System.Numerics.Vectors" version="4.3.0" targetFramework="net46" />
-  <package id="System.ObjectModel" version="4.3.0" targetFramework="net46" />
-  <package id="System.Reflection" version="4.3.0" targetFramework="net46" requireReinstallation="true" />
-  <package id="System.Reflection.Extensions" version="4.3.0" targetFramework="net46" />
-  <package id="System.Reflection.Primitives" version="4.3.0" targetFramework="net46" />
-  <package id="System.Resources.ResourceManager" version="4.3.0" targetFramework="net46" />
-  <package id="System.Runtime" version="4.3.0" targetFramework="net46" requireReinstallation="true" />
-  <package id="System.Runtime.CompilerServices.Unsafe" version="4.4.0-preview1-25305-02" targetFramework="net46" requireReinstallation="true" />
-  <package id="System.Runtime.Extensions" version="4.3.0" targetFramework="net46" requireReinstallation="true" />
-  <package id="System.Runtime.Handles" version="4.3.0" targetFramework="net46" />
-  <package id="System.Runtime.InteropServices" version="4.3.0" targetFramework="net46" requireReinstallation="true" />
-  <package id="System.Runtime.InteropServices.RuntimeInformation" version="4.3.0" targetFramework="net46" />
-  <package id="System.Runtime.Numerics" version="4.3.0" targetFramework="net46" />
-  <package id="System.Security.Cryptography.Algorithms" version="4.3.0" targetFramework="net46" requireReinstallation="true" />
-  <package id="System.Security.Cryptography.Encoding" version="4.3.0" targetFramework="net46" />
-  <package id="System.Security.Cryptography.Primitives" version="4.3.0" targetFramework="net46" />
-  <package id="System.Security.Cryptography.X509Certificates" version="4.3.0" targetFramework="net46" requireReinstallation="true" />
-  <package id="System.Text.Encoding" version="4.3.0" targetFramework="net46" />
-  <package id="System.Text.Encoding.Extensions" version="4.3.0" targetFramework="net46" />
-  <package id="System.Text.RegularExpressions" version="4.3.0" targetFramework="net46" requireReinstallation="true" />
-  <package id="System.Threading" version="4.3.0" targetFramework="net46" />
-  <package id="System.Threading.Tasks" version="4.3.0" targetFramework="net46" />
-  <package id="System.Threading.Tasks.Parallel" version="4.3.0" targetFramework="net46" />
-  <package id="System.Threading.Timer" version="4.3.0" targetFramework="net46" />
-  <package id="System.ValueTuple" version="4.4.0-preview1-25305-02" targetFramework="net46" requireReinstallation="true" />
-  <package id="System.Xml.ReaderWriter" version="4.3.0" targetFramework="net46" />
-  <package id="System.Xml.XDocument" version="4.3.0" targetFramework="net46" />
-</packages>

CatalogLib/stylecop.json

@@ -1,15 +0,0 @@
-{
-    "$schema": "https://raw.githubusercontent.com/DotNetAnalyzers/StyleCopAnalyzers/master/StyleCop.Analyzers/StyleCop.Analyzers/Settings/stylecop.schema.json",
-    "settings":
-    {
-        "orderingRules":
-        {
-            "usingDirectivesPlacement": "outsideNamespace"
-        },
-        "documentationRules":
-        {
-            "xmlHeader": false,
-            "copyrightText": "Copyright (c) Six Labors and contributors.\nLicensed under the Apache License, Version 2.0."
-        }
-    }
-}

CatalogLibVb/CatalogLibVb.csproj

@@ -1,57 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectGuid>{B3352D87-BF9F-4F7A-9162-007492DA76E4}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>CatalogLibVb</RootNamespace>
-    <AssemblyName>CatalogLibVb</AssemblyName>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <SccProjectName>SAK</SccProjectName>
-    <SccLocalPath>SAK</SccLocalPath>
-    <SccAuxPath>SAK</SccAuxPath>
-    <SccProvider>SAK</SccProvider>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="System" />
-    <Reference Include="System.Core" />
-    <Reference Include="System.Xml.Linq" />
-    <Reference Include="System.Data.DataSetExtensions" />
-    <Reference Include="Microsoft.CSharp" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Xml" />
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="Class1.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
-  -->
-</Project>

CatalogLibVb/Class1.cs

@@ -1,12 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace CatalogLibVb
-{
-    public class Class1
-    {
-    }
-}

CatalogLibVb/Properties/AssemblyInfo.cs

@@ -1,36 +0,0 @@
-using System.Reflection;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-// Le informazioni generali relative a un assembly sono controllate dal seguente 
-// set di attributi. Per modificare le informazioni associate a un assembly
-// occorre quindi modificare i valori di questi attributi.
-[assembly: AssemblyTitle("CatalogLibVb")]
-[assembly: AssemblyDescription("")]
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("CatalogLibVb")]
-[assembly: AssemblyCopyright("Copyright ©  2014")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-
-// Se si imposta ComVisible su false, i tipi in questo assembly non saranno visibili 
-// ai componenti COM.  Se è necessario accedere a un tipo in questo assembly da 
-// COM, impostare su true l'attributo ComVisible per tale tipo.
-[assembly: ComVisible(false)]
-
-// Se il progetto viene esposto a COM, il GUID che segue verrà utilizzato per creare l'ID della libreria dei tipi
-[assembly: Guid("367f3879-584c-4780-8ad0-dc84d2e77928")]
-
-// Le informazioni sulla versione di un assembly sono costituite dai seguenti quattro valori:
-//
-//      Numero di versione principale
-//      Numero di versione secondario 
-//      Numero build
-//      Revisione
-//
-// È possibile specificare tutti i valori oppure impostare valori predefiniti per i numeri relativi alla revisione e alla build 
-// utilizzando l'asterisco (*) come descritto di seguito:
-// [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]

CatalogVbLib/CatalogVbLib.vbproj

@@ -1,44 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <TargetFramework>net9.0-windows</TargetFramework>
-    <OutputType>Library</OutputType>
-    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
-    <UseWindowsForms>true</UseWindowsForms>
-  </PropertyGroup>
-	<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-		<DebugType>embedded</DebugType>
-	</PropertyGroup>
-	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
-		<DebugType>embedded</DebugType>
-	</PropertyGroup>
-  <ItemGroup>
-    <Compile Update="My Project\Application.Designer.vb">
-      <AutoGen>True</AutoGen>
-      <DependentUpon>Application.myapp</DependentUpon>
-      <DesignTime>True</DesignTime>
-    </Compile>
-    <Compile Update="My Project\Resources.Designer.vb">
-      <AutoGen>True</AutoGen>
-      <DesignTime>True</DesignTime>
-      <DependentUpon>Resources.resx</DependentUpon>
-    </Compile>
-    <Compile Update="My Project\Settings.Designer.vb">
-      <AutoGen>True</AutoGen>
-      <DependentUpon>Settings.settings</DependentUpon>
-      <DesignTimeSharedInput>True</DesignTimeSharedInput>
-    </Compile>
-  </ItemGroup>
-  <ItemGroup>
-    <None Update="My Project\Application.myapp">
-      <Generator>MyApplicationCodeGenerator</Generator>
-      <LastGenOutput>Application.Designer.vb</LastGenOutput>
-    </None>
-  </ItemGroup>
-  <ItemGroup>
-    <PackageReference Include="Ben.Demystifier" Version="0.4.1" />
-    <PackageReference Include="System.Collections.Immutable" Version="9.0.7" />
-    <PackageReference Include="System.Data.DataSetExtensions" Version="4.5.0" />
-    <PackageReference Include="System.Reflection.Metadata" Version="9.0.7" />
-    <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="6.1.2" />
-  </ItemGroup>
-</Project>

CatalogVbLib/My Project/Application.Designer.vb

@@ -1,13 +0,0 @@
-'------------------------------------------------------------------------------
-' <auto-generated>
-'     This code was generated by a tool.
-'     Runtime Version:4.0.30319.42000
-'
-'     Changes to this file may cause incorrect behavior and will be lost if
-'     the code is regenerated.
-' </auto-generated>
-'------------------------------------------------------------------------------
-
-Option Strict On
-Option Explicit On
-

CatalogVbLib/My Project/Application.myapp

@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<MyApplicationData xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
-  <MySubMain>false</MySubMain>
-  <SingleInstance>false</SingleInstance>
-  <ShutdownMode>0</ShutdownMode>
-  <EnableVisualStyles>true</EnableVisualStyles>
-  <AuthenticationMode>0</AuthenticationMode>
-  <ApplicationType>1</ApplicationType>
-  <SaveMySettingsOnExit>true</SaveMySettingsOnExit>
-</MyApplicationData>

CatalogVbLib/My Project/AssemblyInfo.vb

@@ -1,9 +0,0 @@
-Imports System
-Imports System.Reflection
-Imports System.Runtime.InteropServices
-<Assembly: AssemblyTrademark("")> 
-
-<Assembly: ComVisible(False)>
-
-'Se il progetto viene esposto a COM, il GUID seguente verrà utilizzato come ID della libreria dei tipi
-<Assembly: Guid("ed2ef4c1-7f15-469d-9c14-182f2ebc21b5")> 

CatalogVbLib/My Project/Resources.Designer.vb

@@ -1,63 +0,0 @@
-'------------------------------------------------------------------------------
-' <auto-generated>
-'     This code was generated by a tool.
-'     Runtime Version:4.0.30319.42000
-'
-'     Changes to this file may cause incorrect behavior and will be lost if
-'     the code is regenerated.
-' </auto-generated>
-'------------------------------------------------------------------------------
-
-Option Strict On
-Option Explicit On
-
-Imports System
-
-Namespace My.Resources
-    
-    'This class was auto-generated by the StronglyTypedResourceBuilder
-    'class via a tool like ResGen or Visual Studio.
-    'To add or remove a member, edit your .ResX file then rerun ResGen
-    'with the /str option, or rebuild your VS project.
-    '''<summary>
-    '''  A strongly-typed resource class, for looking up localized strings, etc.
-    '''</summary>
-    <Global.System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0"),  _
-     Global.System.Diagnostics.DebuggerNonUserCodeAttribute(),  _
-     Global.System.Runtime.CompilerServices.CompilerGeneratedAttribute(),  _
-     Global.Microsoft.VisualBasic.HideModuleNameAttribute()>  _
-    Friend Module Resources
-        
-        Private resourceMan As Global.System.Resources.ResourceManager
-        
-        Private resourceCulture As Global.System.Globalization.CultureInfo
-        
-        '''<summary>
-        '''  Returns the cached ResourceManager instance used by this class.
-        '''</summary>
-        <Global.System.ComponentModel.EditorBrowsableAttribute(Global.System.ComponentModel.EditorBrowsableState.Advanced)>  _
-        Friend ReadOnly Property ResourceManager() As Global.System.Resources.ResourceManager
-            Get
-                If Object.ReferenceEquals(resourceMan, Nothing) Then
-                    Dim temp As Global.System.Resources.ResourceManager = New Global.System.Resources.ResourceManager("CatalogVbLib.Resources", GetType(Resources).Assembly)
-                    resourceMan = temp
-                End If
-                Return resourceMan
-            End Get
-        End Property
-        
-        '''<summary>
-        '''  Overrides the current thread's CurrentUICulture property for all
-        '''  resource lookups using this strongly typed resource class.
-        '''</summary>
-        <Global.System.ComponentModel.EditorBrowsableAttribute(Global.System.ComponentModel.EditorBrowsableState.Advanced)>  _
-        Friend Property Culture() As Global.System.Globalization.CultureInfo
-            Get
-                Return resourceCulture
-            End Get
-            Set
-                resourceCulture = value
-            End Set
-        End Property
-    End Module
-End Namespace

CatalogVbLib/My Project/Resources.resx

@@ -1,117 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>

CatalogVbLib/My Project/Settings.Designer.vb

@@ -1,73 +0,0 @@
-'------------------------------------------------------------------------------
-' <auto-generated>
-'     This code was generated by a tool.
-'     Runtime Version:4.0.30319.42000
-'
-'     Changes to this file may cause incorrect behavior and will be lost if
-'     the code is regenerated.
-' </auto-generated>
-'------------------------------------------------------------------------------
-
-Option Strict On
-Option Explicit On
-
-
-Namespace My
-    
-    <Global.System.Runtime.CompilerServices.CompilerGeneratedAttribute(),  _
-     Global.System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "17.11.0.0"),  _
-     Global.System.ComponentModel.EditorBrowsableAttribute(Global.System.ComponentModel.EditorBrowsableState.Advanced)>  _
-    Partial Friend NotInheritable Class MySettings
-        Inherits Global.System.Configuration.ApplicationSettingsBase
-        
-        Private Shared defaultInstance As MySettings = CType(Global.System.Configuration.ApplicationSettingsBase.Synchronized(New MySettings()),MySettings)
-        
-#Region "My.Settings Auto-Save Functionality"
-#If _MyType = "WindowsForms" Then
-    Private Shared addedHandler As Boolean
-
-    Private Shared addedHandlerLockObject As New Object
-
-    <Global.System.Diagnostics.DebuggerNonUserCodeAttribute(), Global.System.ComponentModel.EditorBrowsableAttribute(Global.System.ComponentModel.EditorBrowsableState.Advanced)> _
-    Private Shared Sub AutoSaveSettings(sender As Global.System.Object, e As Global.System.EventArgs)
-        If My.Application.SaveMySettingsOnExit Then
-            My.Settings.Save()
-        End If
-    End Sub
-#End If
-#End Region
-        
-        Public Shared ReadOnly Property [Default]() As MySettings
-            Get
-                
-#If _MyType = "WindowsForms" Then
-               If Not addedHandler Then
-                    SyncLock addedHandlerLockObject
-                        If Not addedHandler Then
-                            AddHandler My.Application.Shutdown, AddressOf AutoSaveSettings
-                            addedHandler = True
-                        End If
-                    End SyncLock
-                End If
-#End If
-                Return defaultInstance
-            End Get
-        End Property
-    End Class
-End Namespace
-
-Namespace My
-    
-    <Global.Microsoft.VisualBasic.HideModuleNameAttribute(),  _
-     Global.System.Diagnostics.DebuggerNonUserCodeAttribute(),  _
-     Global.System.Runtime.CompilerServices.CompilerGeneratedAttribute()>  _
-    Friend Module MySettingsProperty
-        
-        <Global.System.ComponentModel.Design.HelpKeywordAttribute("My.Settings")>  _
-        Friend ReadOnly Property Settings() As Global.CatalogVbLib.My.MySettings
-            Get
-                Return Global.CatalogVbLib.My.MySettings.Default
-            End Get
-        End Property
-    End Module
-End Namespace

CatalogVbLib/My Project/Settings.settings

@@ -1,7 +0,0 @@
-<?xml version='1.0' encoding='utf-8'?>
-<SettingsFile xmlns="http://schemas.microsoft.com/VisualStudio/2004/01/settings" CurrentProfile="(Default)" UseMySettingsClassName="true">
-  <Profiles>
-    <Profile Name="(Default)" />
-  </Profiles>
-  <Settings />
-</SettingsFile>

CatalogVbLib/PicSettings.vb

@@ -1,606 +0,0 @@
-Imports System.IO
-Imports System.Drawing.Drawing2D
-Imports System.Drawing.Imaging
-Imports System.Windows.Forms
-Imports System.Drawing
-
-Public Module PicSettings
-
-    Private _DirectorySorgente As String
-    Private _DirectoryDestinazione As String
-
-    Private _DimVert As Integer
-    Private _MargVert As Integer
-
-
-    Private _DimStandard As Integer
-    Private _DimStandardMiniatura As Integer
-
-    Private _NomeData As Boolean
-    Private _TestoNome As Boolean
-    Private _UsaOrarioMiniatura As Boolean
-    Private _UsaOrarioTestoApplicare As Boolean
-    Private _UsaTempoGaraTestoApplicare As Boolean
-    Private _TestoFirmaStart As String
-    Private _TestoFirmaStartV As String
-    Private _DataPartenza As DateTime
-    Private _TestoOrario As String
-
-    Private _UsaRotazioneAutomatica As Boolean
-    Private _UsaForzaJpg As Boolean
-
-    Private _LarghezzaSmall As Integer
-    Private _AltezzaSmall As Integer
-
-    Private _CreaMiniature As Boolean
-    Private _AggiungiScritteMiniature As Boolean
-    Private _AggTempoGaraMin As Boolean
-    Private _AggNumTempMin As Boolean
-
-    Private _Suffisso As String
-    Private _Codice As String
-
-    Private _Trasparenza As Integer
-    Private _IlFont As String
-    Private _Grassetto As Boolean
-
-    Private _Posizione As String
-    Private _Allineamento As String
-    Private _Margine As Integer
-
-    Private _LogoAltezza As Integer
-    Private _LogoLarghezza As Integer
-
-    Private _fontColoreRGB As System.Drawing.Color
-
-    Private _LogoAggiungi As Boolean
-    Private _LogoNomeFile As String
-    Private _LogoTrasparenza As String
-    Private _LogoMargine As String
-    Private _LogoPosizioneH As String
-    Private _LogoPosizioneV As String
-
-    Private _FotoGrandeDimOrigina As Boolean
-    Private _AltezzaBig As Integer
-    Private _LarghezzaBig As Integer
-    Private _DestDir As DirectoryInfo
-    Private _DimMin As Integer
-
-    Private _TestoMin As Boolean
-
-    Private _SecretDefault As Boolean
-    Private _SecretBig As Boolean
-    Private _SecretSmall As Boolean
-
-    Private _SecretPathSmall As String
-    Private _SecretPathBig As String
-
-    Private _jpegQuality As Long
-    Private _jpegQualityMin As Long
-
-    Private FotoRuotaADestra As Boolean = False
-    Private FotoRuotaASinistra As Boolean = False
-
-    Private TempMinText As String = ""
-
-    Private _mainForm As Form
-
-    'Private progressBar As System.Windows.Forms.ProgressBar
-
-
-
-    Public Property mainForm() As Form
-        Get
-            Return _mainForm
-        End Get
-        Set(ByVal value As Form)
-            _mainForm = value
-        End Set
-    End Property
-
-    Public Property DirectorySorgente() As String
-        Get
-            Return _DirectorySorgente
-        End Get
-        Set(ByVal value As String)
-            _DirectorySorgente = value
-        End Set
-    End Property
-
-    Public Property DirectoryDestinazione() As String
-        Get
-            Return _DirectoryDestinazione
-        End Get
-        Set(ByVal value As String)
-            _DirectoryDestinazione = value
-        End Set
-    End Property
-
-    Public Property TestoFirmaStart() As String
-        Get
-            Return _TestoFirmaStart
-        End Get
-        Set(ByVal value As String)
-            _TestoFirmaStart = value
-        End Set
-    End Property
-
-    Public Property TestoFirmaStartV() As String
-        Get
-            Return _TestoFirmaStartV
-        End Get
-
-        Set(ByVal value As String)
-            _TestoFirmaStartV = value
-        End Set
-    End Property
-
-    Public Property DataPartenza() As DateTime
-        Get
-            Return _DataPartenza
-        End Get
-        Set(ByVal value As DateTime)
-            _DataPartenza = value
-        End Set
-    End Property
-
-    Public Property TestoOrario() As String
-        Get
-            Return _TestoOrario
-        End Get
-        Set(ByVal value As String)
-            _TestoOrario = value
-        End Set
-    End Property
-
-    Public Property DimStandard() As Integer
-        Get
-            Return _DimStandard
-        End Get
-        Set(ByVal value As Integer)
-            _DimStandard = value
-        End Set
-    End Property
-
-    Public Property DimStandardMiniatura() As Integer
-        Get
-            Return _DimStandardMiniatura
-        End Get
-        Set(ByVal value As Integer)
-            _DimStandardMiniatura = value
-        End Set
-    End Property
-
-    Public Property NomeData() As Boolean
-        Get
-            Return _NomeData
-        End Get
-        Set(ByVal value As Boolean)
-            _NomeData = value
-        End Set
-    End Property
-
-    Public Property TestoNome() As Boolean
-        Get
-            Return _TestoNome
-        End Get
-        Set(ByVal value As Boolean)
-            _TestoNome = value
-        End Set
-    End Property
-
-    Public Property UsaOrarioMiniatura() As Boolean
-        Get
-            Return _UsaOrarioMiniatura
-        End Get
-        Set(ByVal value As Boolean)
-            _UsaOrarioMiniatura = value
-        End Set
-    End Property
-
-    Public Property UsaOrarioTestoApplicare() As Boolean
-        Get
-            Return _UsaOrarioTestoApplicare
-        End Get
-        Set(ByVal value As Boolean)
-            _UsaOrarioTestoApplicare = value
-        End Set
-    End Property
-
-    Public Property UsaTempoGaraTestoApplicare() As Boolean
-        Get
-            Return _UsaTempoGaraTestoApplicare
-        End Get
-        Set(ByVal value As Boolean)
-            _UsaTempoGaraTestoApplicare = value
-        End Set
-    End Property
-
-    Public Property UsaRotazioneAutomatica() As Boolean
-        Get
-            Return _UsaRotazioneAutomatica
-        End Get
-        Set(ByVal value As Boolean)
-            _UsaRotazioneAutomatica = value
-        End Set
-    End Property
-
-    Public Property UsaForzaJpg() As Boolean
-        Get
-            Return _UsaForzaJpg
-        End Get
-        Set(ByVal value As Boolean)
-            _UsaForzaJpg = value
-        End Set
-    End Property
-
-
-
-    Public Property LarghezzaSmall() As Integer
-        Get
-            Return _LarghezzaSmall
-        End Get
-        Set(ByVal value As Integer)
-            _LarghezzaSmall = value
-        End Set
-    End Property
-
-    Public Property AltezzaSmall() As Integer
-        Get
-            Return _AltezzaSmall
-        End Get
-        Set(ByVal value As Integer)
-            _AltezzaSmall = value
-        End Set
-    End Property
-
-
-    Public Property CreaMiniature() As Boolean
-        Get
-            Return _CreaMiniature
-        End Get
-        Set(ByVal value As Boolean)
-            _CreaMiniature = value
-        End Set
-    End Property
-
-    Public Property AggiungiScritteMiniature() As Boolean
-        Get
-            Return _AggiungiScritteMiniature
-        End Get
-        Set(ByVal value As Boolean)
-            _AggiungiScritteMiniature = value
-        End Set
-    End Property
-
-
-    Public Property Suffisso() As String
-        Get
-            Return _Suffisso
-        End Get
-        Set(ByVal value As String)
-            _Suffisso = value
-        End Set
-    End Property
-
-    Public Property Codice() As String
-        Get
-            Return _Codice
-        End Get
-        Set(ByVal value As String)
-            _Codice = value
-        End Set
-    End Property
-
-
-    Public Property Trasparenza() As Integer
-        Get
-            Return _Trasparenza
-        End Get
-        Set(ByVal value As Integer)
-            _Trasparenza = value
-        End Set
-    End Property
-
-    Public Property IlFont() As String
-        Get
-            Return _IlFont
-        End Get
-        Set(ByVal value As String)
-            _IlFont = value
-        End Set
-    End Property
-
-    Public Property Grassetto() As Boolean
-        Get
-            Return _Grassetto
-        End Get
-        Set(ByVal value As Boolean)
-            _Grassetto = value
-        End Set
-    End Property
-
-    Public Property Posizione() As String
-        Get
-            Return _Posizione
-        End Get
-        Set(ByVal value As String)
-            _Posizione = value
-        End Set
-    End Property
-
-    Public Property Allineamento() As String
-        Get
-            Return _Allineamento
-        End Get
-        Set(ByVal value As String)
-            _Allineamento = value
-        End Set
-    End Property
-
-    Public Property Margine() As Integer
-        Get
-            Return _Margine
-        End Get
-        Set(ByVal value As Integer)
-            _Margine = value
-        End Set
-    End Property
-
-    Public Property LogoAltezza() As Integer
-        Get
-            Return _LogoAltezza
-        End Get
-        Set(ByVal value As Integer)
-            _LogoAltezza = value
-        End Set
-    End Property
-
-    Public Property LogoLarghezza() As Integer
-        Get
-            Return _LogoLarghezza
-        End Get
-        Set(ByVal value As Integer)
-            _LogoLarghezza = value
-        End Set
-    End Property
-
-    Public Property fontColoreRGB() As Color
-        Get
-            Return _fontColoreRGB
-        End Get
-        Set(ByVal value As Color)
-            _fontColoreRGB = value
-        End Set
-    End Property
-
-    Public Property LogoAggiungi() As Boolean
-        Get
-            Return _LogoAggiungi
-        End Get
-        Set(ByVal value As Boolean)
-            _LogoAggiungi = value
-        End Set
-    End Property
-
-    Public Property LogoNomeFile() As String
-        Get
-            Return _LogoNomeFile
-        End Get
-        Set(ByVal value As String)
-            _LogoNomeFile = value
-        End Set
-    End Property
-
-    Public Property LogoTrasparenza() As String
-        Get
-            Return _LogoTrasparenza
-        End Get
-        Set(ByVal value As String)
-            _LogoTrasparenza = value
-        End Set
-    End Property
-
-    Public Property LogoMargine() As String
-        Get
-            Return _LogoMargine
-        End Get
-        Set(ByVal value As String)
-            _LogoMargine = value
-        End Set
-    End Property
-
-    Public Property LogoPosizioneH() As String
-        Get
-            Return _LogoPosizioneH
-        End Get
-        Set(ByVal value As String)
-            _LogoPosizioneH = value
-        End Set
-    End Property
-
-    Public Property LogoPosizioneV() As String
-        Get
-            Return _LogoPosizioneV
-        End Get
-        Set(ByVal value As String)
-            _LogoPosizioneV = value
-        End Set
-    End Property
-
-    Public Property FotoGrandeDimOrigina() As Boolean
-        Get
-            Return _FotoGrandeDimOrigina
-        End Get
-        Set(ByVal value As Boolean)
-            _FotoGrandeDimOrigina = value
-        End Set
-    End Property
-
-    Public Property AltezzaBig() As Integer
-        Get
-            Return _AltezzaBig
-        End Get
-        Set(ByVal value As Integer)
-            _AltezzaBig = value
-        End Set
-    End Property
-
-    Public Property LarghezzaBig() As Integer
-        Get
-            Return _LarghezzaBig
-        End Get
-        Set(ByVal value As Integer)
-            _LarghezzaBig = value
-        End Set
-    End Property
-
-    Public Property DestDir() As DirectoryInfo
-        Get
-            Return _DestDir
-        End Get
-        Set(ByVal value As DirectoryInfo)
-            _DestDir = value
-        End Set
-    End Property
-
-    Public Property DimVert() As Integer
-        Get
-            Return _DimVert
-
-        End Get
-        Set(ByVal value As Integer)
-            _DimVert = value
-
-        End Set
-    End Property
-
-    Public Property MargVert() As Integer
-        Get
-            Return _MargVert
-
-        End Get
-        Set(ByVal value As Integer)
-            _MargVert = value
-        End Set
-    End Property
-
-    Public Property TestoMin() As Boolean
-        Get
-            Return _TestoMin
-
-        End Get
-        Set(ByVal value As Boolean)
-            _TestoMin = value
-
-        End Set
-    End Property
-
-    Public Property DimMin() As Integer
-        Get
-            Return _DimMin
-
-        End Get
-        Set(ByVal value As Integer)
-            _DimMin = value
-
-        End Set
-    End Property
-
-    Public Property SecretDefault() As Boolean
-        Get
-            Return _SecretDefault
-
-        End Get
-        Set(ByVal value As Boolean)
-            _SecretDefault = value
-
-        End Set
-    End Property
-
-    Public Property SecretBig() As Boolean
-        Get
-            Return _SecretBig
-
-        End Get
-        Set(ByVal value As Boolean)
-            _SecretBig = value
-
-        End Set
-    End Property
-
-    Public Property SecretSmall() As Boolean
-        Get
-            Return _SecretSmall
-
-        End Get
-        Set(ByVal value As Boolean)
-            _SecretSmall = value
-
-        End Set
-    End Property
-
-    Public Property SecretPathSmall() As String
-        Get
-            Return _SecretPathSmall
-
-        End Get
-        Set(ByVal value As String)
-            _SecretPathSmall = value
-
-        End Set
-    End Property
-
-    Public Property SecretPathBig() As String
-        Get
-            Return _SecretPathBig
-
-        End Get
-        Set(ByVal value As String)
-            _SecretPathBig = value
-
-        End Set
-    End Property
-
-    Public Property AggTempoGaraMin() As Boolean
-        Get
-            Return _AggTempoGaraMin
-
-        End Get
-        Set(ByVal value As Boolean)
-            _AggTempoGaraMin = value
-
-        End Set
-    End Property
-
-    Public Property AggNumTempMin() As Boolean
-        Get
-            Return _AggNumTempMin
-
-        End Get
-        Set(ByVal value As Boolean)
-            _AggNumTempMin = value
-
-        End Set
-    End Property
-
-    Public Property jpegQuality() As Long
-        Get
-            Return _jpegQuality
-        End Get
-        Set(ByVal value As Long)
-            _jpegQuality = value
-        End Set
-
-    End Property
-
-    Public Property jpegQualityMin() As Long
-        Get
-            Return _jpegQualityMin
-        End Get
-        Set(ByVal value As Long)
-            _jpegQualityMin = value
-        End Set
-
-    End Property
-End Module

ImageCatalogCS/AboutForm.Designer.cs

@@ -1,101 +0,0 @@
-namespace ImageCatalogCS
-{
-    partial class AboutForm
-    {
-        /// <summary>
-        /// Required designer variable.
-        /// </summary>
-        private System.ComponentModel.IContainer components = null;
-
-        /// <summary>
-        /// Clean up any resources being used.
-        /// </summary>
-        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-        protected override void Dispose(bool disposing)
-        {
-            if (disposing && (components != null))
-            {
-                components.Dispose();
-            }
-            base.Dispose(disposing);
-        }
-
-        #region Windows Form Designer generated code
-
-        /// <summary>
-        /// Required method for Designer support - do not modify
-        /// the contents of this method with the code editor.
-        /// </summary>
-        private void InitializeComponent()
-        {
-            System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(AboutForm));
-            this.label1 = new System.Windows.Forms.Label();
-            this.label2 = new System.Windows.Forms.Label();
-            this.button1 = new System.Windows.Forms.Button();
-            this.pictureBox1 = new System.Windows.Forms.PictureBox();
-            ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).BeginInit();
-            this.SuspendLayout();
-            // 
-            // label1
-            // 
-            this.label1.AutoSize = true;
-            this.label1.Location = new System.Drawing.Point(12, 213);
-            this.label1.Name = "label1";
-            this.label1.Size = new System.Drawing.Size(75, 13);
-            this.label1.TabIndex = 0;
-            this.label1.Text = "Image Catalog";
-            // 
-            // label2
-            // 
-            this.label2.AutoSize = true;
-            this.label2.Location = new System.Drawing.Point(350, 213);
-            this.label2.Name = "label2";
-            this.label2.Size = new System.Drawing.Size(66, 13);
-            this.label2.TabIndex = 1;
-            this.label2.Text = "Versione 3.0";
-            // 
-            // button1
-            // 
-            this.button1.Location = new System.Drawing.Point(176, 239);
-            this.button1.Name = "button1";
-            this.button1.Size = new System.Drawing.Size(75, 23);
-            this.button1.TabIndex = 2;
-            this.button1.Text = "Chiudi";
-            this.button1.UseVisualStyleBackColor = true;
-            this.button1.Click += new System.EventHandler(this.button1_Click);
-            // 
-            // pictureBox1
-            // 
-            this.pictureBox1.Image = ((System.Drawing.Image)(resources.GetObject("pictureBox1.Image")));
-            this.pictureBox1.InitialImage = ((System.Drawing.Image)(resources.GetObject("pictureBox1.InitialImage")));
-            this.pictureBox1.Location = new System.Drawing.Point(15, 13);
-            this.pictureBox1.Name = "pictureBox1";
-            this.pictureBox1.Size = new System.Drawing.Size(401, 197);
-            this.pictureBox1.TabIndex = 3;
-            this.pictureBox1.TabStop = false;
-            // 
-            // AboutForm
-            // 
-            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-            this.ClientSize = new System.Drawing.Size(433, 274);
-            this.Controls.Add(this.pictureBox1);
-            this.Controls.Add(this.button1);
-            this.Controls.Add(this.label2);
-            this.Controls.Add(this.label1);
-            this.Name = "AboutForm";
-            this.Text = "AboutForm";
-            ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).EndInit();
-            this.ResumeLayout(false);
-            this.PerformLayout();
-
-        }
-
-        #endregion
-
-        private System.Windows.Forms.Label label1;
-        private System.Windows.Forms.Label label2;
-        private System.Windows.Forms.Button button1;
-        private System.Windows.Forms.PictureBox pictureBox1;
-    }
-}

ImageCatalogCS/AboutForm.cs

@@ -1,25 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Data;
-using System.Drawing;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Windows.Forms;
-
-namespace ImageCatalogCS
-{
-    public partial class AboutForm : Form
-    {
-        public AboutForm()
-        {
-            InitializeComponent();
-        }
-
-        private void button1_Click(object sender, EventArgs e)
-        {
-            this.Close();
-        }
-    }
-}

ImageCatalogCS/AboutForm.resx

@@ -1,229 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <assembly alias="System.Drawing" name="System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
-  <data name="pictureBox1.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAAZ4AAADQCAIAAAC4O5DwAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAS
-        cwAAEnMBjCK5BwAAC05JREFUeF7t2sGBG0cORmEn4PPmooCUxO7FGTgaJ+NgtE0OKZMeTTdQDVQBf7/v
-        4svuDLsK9boo6bcfACCHtAEQRNoACCJtAASRNgCCSBsAQaQNgCDSBkAQaQMgiLQBEETaAAgibQAEkTYA
-        gkgbAEGkDYAg0gZAEGkDIIi0ARBE2gAIIm0ABJE2AIJIGwBBpA2AINIGQBBpAyCItAEQRNoACCJtAASR
-        NgCCSBsAQaQNgCDSBkAQaQMgiLQBEETaAAgibQAEkTYAgkgbAEGkDYAg0pbqr++/Dfn259+PnwBhjEci
-        0hZndFBtvv/1+DXoifGYi7SdkzuvX+Gt3QTjsQ5pG/H3n98eU7QaL+uCGI8KSJtHnZn9NxJXAONRCWkz
-        qTu0b/gmsgbjUdDKtB0PRIG9aDK1r1asmvsPlUSO2cXGo8WRfViXNsNQLL5GNxzbF3MX74Jpu+Z4HG90
-        lZ1dlTbLXCwsW+7YHm5+2F+sTVvCa6UtvWr7q7N0PAy/vMberkmbZTSWrU/Y4OxyTtWJDzUlb9dJ25zx
-        2Hj2beZ4lD68L1akzfTOm3IgP5k2tzeD+z9yZUgftWukbep4bEYWacJ4WJZh/f7OT5tt6ReUbfbc3px6
-        TOcQpy6pftpWjMdmfNcSx8O0Fqt3eHbabOs9fVVGXnUxAh7Vfujy1lU7bevGY3N2pTLGo+gxfjM5bbZl
-        nrwkSwd3E3Odsk5wzuVNOG3G8fjP478ZAvYsejxsPy9n2Gymps24vFPXwzS4vz/+myTumNuOYcICq6bN
-        tKDf/vff5Jdj0GpFjkfFw/xmYtqMb7+ZM2/5SN//sJ7az7toPvChD234reGLLJk203hsm25++BITEjUe
-        Bc/zm2lpMy7EzJU43uNtFE2fe/9DW8Y3+rGPP3bsbzQf0adlE29mGo9NxwkJGY+CR/rVrLRZR3/aMhzu
-        i3VuTZ/YMAWf3+hnHa554K9US5txPCz/y6oTEjAe1l2Pn22DOWkz7NuHWWtwtCfPz2Gf8ENHPyrlrB/9
-        0rD11kqbdTw2rSfk9HhYt33Fbk9Jm3nuw07avv3P87INsWU4+GlZ229+2jPMW/y0YtiNPAvWf0LOjYd5
-        3ycd7RcT0na0+z/Nmfb9j/P+GaKrsP/z8nZ/9/eGLLt5xJ/mbLafZzw2EhNyZjyKne4X+WkzD/2UZ9/d
-        iX9/gv1tG5mzM0N0iuu5B5h3+Wn6pJt4l0llQk6Mx/4SvJp8cctOm/3BC876iQ3/QvxRKEIkbV5MSN0j
-        npw2+8RXHPWEN+jujyRt3TAhG3vbpn7+1LQVfWYzBteMtH12nQmx7/7Ebc9MW/ey7T/A0CbtLwlp64YJ
-        +eDY/mmPkJi2io/rEz9mu2vS+bSTtl+40IQUPOx5aetftqNn8A/a/s8ruwwGjt3+oJE2JuTJMQCTtj4r
-        bfuvs3d1N+zoKXyf/OCntT7sV00bE/JUrm1JadMom+E57B8+8EcV5E7bh9bPfMeEPFVrW07aPINe+/V9
-        3GjT5z/+Mc1P+WDafur79EzIk2cGJjxLStp0ymYauaOHsCxH9WU4cjZtH1quAhPyYFqIp/y2ZaRNqWwb
-        8+N83i3z/7V72YLSdtdvLZiQD7XalpA2z5S3GGPXjo1oH7bQtN1N+MISiAn5UKpt8WlzDXmTCc4d3V7H
-        +Nei03bTaV2YkLtKhz88bYpl26SNrsCN7SYjbZtGq8OE3BQ6/tFpcz1ar2OdcXo7XUx2JaVt02hImBBn
-        4FMfLjhtwmXbBL+Y2z3/jry0bS57uW84IXXaFpu2Qs3OEnWGWz7811LT1uuMX3xCytxuQtPmK1vbS8vp
-        V7PSde0hOW3N1uzKE1ImAqFp881373vL6FkWu609paet33G/6oRUqUBk2nzPJHF18TyyaNQ+TEhbz5G5
-        3oQ4r6xpDx2Ytot8Hf21rydY7EG/8Hz+naeNqF/jw3+dCfFtdNrTB6bN90TSdxh87dyfQ13jRdFbkWtb
-        XNoufWmDz4kbHO/E8py7m7SjcWkrcg1FE8N1o23VOa9tSS0IS1uRWyj6GP1qymuxuhLXtrC0cWmD39jV
-        jekprsS1LSptXNowYuzmxvgUV+HaFpW2EldQNDR0cWN+ahNKW4kbKFoaaRsDVFuFHgSlzTmeTCb+Qdvk
-        eP+cIePatiZtfJ/Ai5G2MUKlFQhCTNoqRBptjfxdAte20gp8jVuSNsYSb0baxuuxsgJFIG0oYOArKWmr
-        zPuyStjNmLQVuH6is4G0MUSVXTVtvHDxbuAbKWmrjLQBd3wjFbM+CaQNFZA2Mc4NTbiDkzZUQNrEkDbg
-        hrSJIW3ADWkTsz4JpA0V+NPG35CWRtqAG9KmhX+yC9wM/Ls23o+VOTc0owgxaSvwIOiMtIkhbcAN30fF
-        OIuQ8Z6KSRt/2IYzuLSpKRAE0ob1uLSp8e1oym4GpY1vpFfyc7eDXlH+svFyrK1CD4LSVqHSyPLl5sbs
-        I2WTU+CP2sLSVuFZEMOxlxFtGygbr8biKtx0otLmfBjSVtGKyDjfiXeUrbgSF52wtPmehuEsaX7bBn4j
-        w1NeiRiEpY1rm4LJd6iRsDE69ZVoQVzauLYpGGnb4GYO/SrK1kCNFMSljWubhMHgeOdz6L624ZXYQI0S
-        BKaNa5uG0epYt3Qwnne8EBvwbXDalgamrcoj4aQz7dl8WbjhZj7xOmzBtc95exqZtirPhLNORygDA9ND
-        lRtOaNq4tskoFzfC1oVrdBIjEJo2X9sY1tJKxY1ZaaNMA2LT5nsurm21+S7hiRiURjyvxNQ3VnDaytxG
-        EaLA1Y0LWyt1AhCdtjrRRoi1VzcmpJlCX9vC0+ZqG9e2DlbVjenop9Dpj08bbVM0O29c11qqdPYT0uZ5
-        Pia4kVl5433XlWdC0nc5I220TVhu36haZ57ZyD/4KWnztI1h7ig8cLziBNQ69jlpo20XcTpxJE1HsUOf
-        lDbHYzLcKoydY8M1OV5zU64zWWmjbcCVVCtbXtocj0rbgObKlS0xbbStiN19EF76qz73EgUPe2LaHF9K
-        GbRU+3Onufi7s8e8RSt41FPTRtvK2N8JteW/1tMWYD7oE/89RG7a7PdUxi3b0fRNHLpURyOn8pyVVCxb
-        dtrsT03b0h2+Z/qf+sNpI2wJap7x9LTRtkqON6Pv2T/+hsCIZTB/M5s8WvlpMz86gzeDZTf65c3w/mS8
-        cpQ93hPSZr+48W1hCtMwtimB7WgxWkmsZZu/AVPSVvj5L8q4IcX7xitzOeMWrBikOWkrvQQXZX3dlCyD
-        NWpMVC7jPiyZoFlpE7kniLEXosjO2Ht8x3UtVe0zPS1t5oVgHOfy5O1mxaA6i3bHSzJb8QM9MW3WU0Tb
-        pvPm7SG3HoMf6oYRmqD6aZ6aNmPned+uMHIz+mx4kk+E7B1Zm8O0YSuP8ty0GQ8QbVslpm+rULVpbIOy
-        dENmp81Ye4Z0oYZ942U4V4dDPD9ttnVhVldrEjgGZT7TaCy/naxImy1uXNxKqFs4BmQRy0gUeOOsSZsp
-        boxuJXUSx1ysZTi6Ja7Sq9JmWSG+a5RkuXLHYxhqMLziimzVurRZzggv6OJyM8f2l9PoQrIybVA0Wjuu
-        ZQhF2gAIIm0ABJE2AIJIGwBBpA2AINIGQBBpAyCItAEQRNoACCJtAASRNgCCSBsAQaQNgCDSBkAQaQMg
-        iLQBEETaAAgibQAEkTYAgkgbAEGkDYAg0gZAEGkDIIi0ARBE2gAIIm0ABJE2AIJIGwBBpA2AINIGQBBp
-        AyCItAEQRNoACCJtAASRNgCCSBsAQaQNgCDSBkAQaQMgiLQBEETaAAgibQAEkTYAgkgbAEGkDYAg0gZA
-        EGkDIIi0ARBE2gAIIm0ABJE2AIJIGwA5P378HyuEmb0husDDAAAAAElFTkSuQmCC
-</value>
-  </data>
-  <data name="pictureBox1.InitialImage" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAAZ4AAADQCAIAAAC4O5DwAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAS
-        cwAAEnMBjCK5BwAAC05JREFUeF7t2sGBG0cORmEn4PPmooCUxO7FGTgaJ+NgtE0OKZMeTTdQDVQBf7/v
-        4svuDLsK9boo6bcfACCHtAEQRNoACCJtAASRNgCCSBsAQaQNgCDSBkAQaQMgiLQBEETaAAgibQAEkTYA
-        gkgbAEGkDYAg0gZAEGkDIIi0ARBE2gAIIm0ABJE2AIJIGwBBpA2AINIGQBBpAyCItAEQRNoACCJtAASR
-        NgCCSBsAQaQNgCDSBkAQaQMgiLQBEETaAAgibQAEkTYAgkgbAEGkDYAg0pbqr++/Dfn259+PnwBhjEci
-        0hZndFBtvv/1+DXoifGYi7SdkzuvX+Gt3QTjsQ5pG/H3n98eU7QaL+uCGI8KSJtHnZn9NxJXAONRCWkz
-        qTu0b/gmsgbjUdDKtB0PRIG9aDK1r1asmvsPlUSO2cXGo8WRfViXNsNQLL5GNxzbF3MX74Jpu+Z4HG90
-        lZ1dlTbLXCwsW+7YHm5+2F+sTVvCa6UtvWr7q7N0PAy/vMberkmbZTSWrU/Y4OxyTtWJDzUlb9dJ25zx
-        2Hj2beZ4lD68L1akzfTOm3IgP5k2tzeD+z9yZUgftWukbep4bEYWacJ4WJZh/f7OT5tt6ReUbfbc3px6
-        TOcQpy6pftpWjMdmfNcSx8O0Fqt3eHbabOs9fVVGXnUxAh7Vfujy1lU7bevGY3N2pTLGo+gxfjM5bbZl
-        nrwkSwd3E3Odsk5wzuVNOG3G8fjP478ZAvYsejxsPy9n2Gymps24vFPXwzS4vz/+myTumNuOYcICq6bN
-        tKDf/vff5Jdj0GpFjkfFw/xmYtqMb7+ZM2/5SN//sJ7az7toPvChD234reGLLJk203hsm25++BITEjUe
-        Bc/zm2lpMy7EzJU43uNtFE2fe/9DW8Y3+rGPP3bsbzQf0adlE29mGo9NxwkJGY+CR/rVrLRZR3/aMhzu
-        i3VuTZ/YMAWf3+hnHa554K9US5txPCz/y6oTEjAe1l2Pn22DOWkz7NuHWWtwtCfPz2Gf8ENHPyrlrB/9
-        0rD11kqbdTw2rSfk9HhYt33Fbk9Jm3nuw07avv3P87INsWU4+GlZ229+2jPMW/y0YtiNPAvWf0LOjYd5
-        3ycd7RcT0na0+z/Nmfb9j/P+GaKrsP/z8nZ/9/eGLLt5xJ/mbLafZzw2EhNyZjyKne4X+WkzD/2UZ9/d
-        iX9/gv1tG5mzM0N0iuu5B5h3+Wn6pJt4l0llQk6Mx/4SvJp8cctOm/3BC876iQ3/QvxRKEIkbV5MSN0j
-        npw2+8RXHPWEN+jujyRt3TAhG3vbpn7+1LQVfWYzBteMtH12nQmx7/7Ebc9MW/ey7T/A0CbtLwlp64YJ
-        +eDY/mmPkJi2io/rEz9mu2vS+bSTtl+40IQUPOx5aetftqNn8A/a/s8ruwwGjt3+oJE2JuTJMQCTtj4r
-        bfuvs3d1N+zoKXyf/OCntT7sV00bE/JUrm1JadMom+E57B8+8EcV5E7bh9bPfMeEPFVrW07aPINe+/V9
-        3GjT5z/+Mc1P+WDafur79EzIk2cGJjxLStp0ymYauaOHsCxH9WU4cjZtH1quAhPyYFqIp/y2ZaRNqWwb
-        8+N83i3z/7V72YLSdtdvLZiQD7XalpA2z5S3GGPXjo1oH7bQtN1N+MISiAn5UKpt8WlzDXmTCc4d3V7H
-        +Nei03bTaV2YkLtKhz88bYpl26SNrsCN7SYjbZtGq8OE3BQ6/tFpcz1ar2OdcXo7XUx2JaVt02hImBBn
-        4FMfLjhtwmXbBL+Y2z3/jry0bS57uW84IXXaFpu2Qs3OEnWGWz7811LT1uuMX3xCytxuQtPmK1vbS8vp
-        V7PSde0hOW3N1uzKE1ImAqFp881373vL6FkWu609paet33G/6oRUqUBk2nzPJHF18TyyaNQ+TEhbz5G5
-        3oQ4r6xpDx2Ytot8Hf21rydY7EG/8Hz+naeNqF/jw3+dCfFtdNrTB6bN90TSdxh87dyfQ13jRdFbkWtb
-        XNoufWmDz4kbHO/E8py7m7SjcWkrcg1FE8N1o23VOa9tSS0IS1uRWyj6GP1qymuxuhLXtrC0cWmD39jV
-        jekprsS1LSptXNowYuzmxvgUV+HaFpW2EldQNDR0cWN+ahNKW4kbKFoaaRsDVFuFHgSlzTmeTCb+Qdvk
-        eP+cIePatiZtfJ/Ai5G2MUKlFQhCTNoqRBptjfxdAte20gp8jVuSNsYSb0baxuuxsgJFIG0oYOArKWmr
-        zPuyStjNmLQVuH6is4G0MUSVXTVtvHDxbuAbKWmrjLQBd3wjFbM+CaQNFZA2Mc4NTbiDkzZUQNrEkDbg
-        hrSJIW3ADWkTsz4JpA0V+NPG35CWRtqAG9KmhX+yC9wM/Ls23o+VOTc0owgxaSvwIOiMtIkhbcAN30fF
-        OIuQ8Z6KSRt/2IYzuLSpKRAE0ob1uLSp8e1oym4GpY1vpFfyc7eDXlH+svFyrK1CD4LSVqHSyPLl5sbs
-        I2WTU+CP2sLSVuFZEMOxlxFtGygbr8biKtx0otLmfBjSVtGKyDjfiXeUrbgSF52wtPmehuEsaX7bBn4j
-        w1NeiRiEpY1rm4LJd6iRsDE69ZVoQVzauLYpGGnb4GYO/SrK1kCNFMSljWubhMHgeOdz6L624ZXYQI0S
-        BKaNa5uG0epYt3Qwnne8EBvwbXDalgamrcoj4aQz7dl8WbjhZj7xOmzBtc95exqZtirPhLNORygDA9ND
-        lRtOaNq4tskoFzfC1oVrdBIjEJo2X9sY1tJKxY1ZaaNMA2LT5nsurm21+S7hiRiURjyvxNQ3VnDaytxG
-        EaLA1Y0LWyt1AhCdtjrRRoi1VzcmpJlCX9vC0+ZqG9e2DlbVjenop9Dpj08bbVM0O29c11qqdPYT0uZ5
-        Pia4kVl5433XlWdC0nc5I220TVhu36haZ57ZyD/4KWnztI1h7ig8cLziBNQ69jlpo20XcTpxJE1HsUOf
-        lDbHYzLcKoydY8M1OV5zU64zWWmjbcCVVCtbXtocj0rbgObKlS0xbbStiN19EF76qz73EgUPe2LaHF9K
-        GbRU+3Onufi7s8e8RSt41FPTRtvK2N8JteW/1tMWYD7oE/89RG7a7PdUxi3b0fRNHLpURyOn8pyVVCxb
-        dtrsT03b0h2+Z/qf+sNpI2wJap7x9LTRtkqON6Pv2T/+hsCIZTB/M5s8WvlpMz86gzeDZTf65c3w/mS8
-        cpQ93hPSZr+48W1hCtMwtimB7WgxWkmsZZu/AVPSVvj5L8q4IcX7xitzOeMWrBikOWkrvQQXZX3dlCyD
-        NWpMVC7jPiyZoFlpE7kniLEXosjO2Ht8x3UtVe0zPS1t5oVgHOfy5O1mxaA6i3bHSzJb8QM9MW3WU0Tb
-        pvPm7SG3HoMf6oYRmqD6aZ6aNmPned+uMHIz+mx4kk+E7B1Zm8O0YSuP8ty0GQ8QbVslpm+rULVpbIOy
-        dENmp81Ye4Z0oYZ942U4V4dDPD9ttnVhVldrEjgGZT7TaCy/naxImy1uXNxKqFs4BmQRy0gUeOOsSZsp
-        boxuJXUSx1ysZTi6Ja7Sq9JmWSG+a5RkuXLHYxhqMLziimzVurRZzggv6OJyM8f2l9PoQrIybVA0Wjuu
-        ZQhF2gAIIm0ABJE2AIJIGwBBpA2AINIGQBBpAyCItAEQRNoACCJtAASRNgCCSBsAQaQNgCDSBkAQaQMg
-        iLQBEETaAAgibQAEkTYAgkgbAEGkDYAg0gZAEGkDIIi0ARBE2gAIIm0ABJE2AIJIGwBBpA2AINIGQBBp
-        AyCItAEQRNoACCJtAASRNgCCSBsAQaQNgCDSBkAQaQMgiLQBEETaAAgibQAEkTYAgkgbAEGkDYAg0gZA
-        EGkDIIi0ARBE2gAIIm0ABJE2AIJIGwA5P378HyuEmb0husDDAAAAAElFTkSuQmCC
-</value>
-  </data>
-</root>

ImageCatalogCS/App.config

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<configuration>
-    <startup> 
-        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.8"/>
-    </startup>
-</configuration>

ImageCatalogCS/CreaImmagineSeparateThread.cs

@@ -1,12 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace ImageCatalogCS
-{
-    class CreaImmagineSeparateThread
-    {
-    }
-}

ImageCatalogCS/FileHelper.cs

@@ -1,173 +0,0 @@
-using Microsoft.VisualBasic;
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Data;
-using System.Diagnostics;
-using System.IO;
-
-public class FileHelper
-{
-    //Private dirSourceDest As Dictionary(Of FileInfo, DirectoryInfo)
-    private int filesPerFolder;
-    private string suffix;
-    private int counterSize;
-    private int numerationType;
-    private string filter;
-    private bool separateFiles;
-
-    private string extensions = "*.jpg,*.png,*.gif";
-
-    public enum numerazione
-    {
-        Progressiva,
-        Files
-    }
-    /// <summary>
-    /// Preparazione per la separazione
-    /// </summary>
-    /// <param name="filesPerFolder"></param>
-    /// <param name="suffix"></param>
-    /// <param name="counterSize"></param>
-    /// <param name="numerationType"></param>
-    /// <remarks></remarks>
-    public FileHelper(int filesPerFolder, string suffix, int counterSize, int numerationType)
-    {
-        this.filesPerFolder = filesPerFolder;
-        this.suffix = suffix;
-        this.counterSize = counterSize;
-        this.numerationType = numerationType;
-        this.separateFiles = true;
-    }
-
-    /// <summary>
-    /// nessuna separazione
-    /// </summary>
-    /// <remarks></remarks>
-    public FileHelper()
-    {
-        this.separateFiles = false;
-    }
-
-
-    public Dictionary<FileInfo, DirectoryInfo> GetFilesRecursive(DirectoryInfo root, DirectoryInfo destRoot, string filter)
-    {
-        Dictionary<FileInfo, DirectoryInfo> dirSourceDest = new Dictionary<FileInfo, DirectoryInfo>();
-        List<FileInfo> result = new List<FileInfo>();
-
-        //Dim stack As New Stack(Of DirectoryInfo)
-        Stack<KeyValuePair<DirectoryInfo, DirectoryInfo>> stack = new Stack<KeyValuePair<DirectoryInfo, DirectoryInfo>>();
-
-
-        this.filter = filter;
-        KeyValuePair<DirectoryInfo, DirectoryInfo> pair = new KeyValuePair<DirectoryInfo, DirectoryInfo>();
-
-
-        //stack.Push(root)
-        stack.Push(new KeyValuePair<DirectoryInfo, DirectoryInfo>(root, destRoot));
-
-        while ((stack.Count > 0))
-        {
-            KeyValuePair<DirectoryInfo, DirectoryInfo> curDirKV = stack.Pop();
-            //curDirKP = stack.Pop()
-            DirectoryInfo dir = curDirKV.Key;
-            DirectoryInfo dDir = curDirKV.Value;
-            try
-            {
-                //result.AddRange(dir.GetFiles(filter, SearchOption.TopDirectoryOnly))
-                // dividere file qui
-                if (filesPerFolder > 0 & separateFiles)
-                {
-                    appendDictionary(dirSourceDest, dividiFilesInDir(dir, dDir));
-                }
-                else
-                {
-                    appendDictionary(dirSourceDest, getAllFilesInDir(dir, dDir));
-                }
-
-
-
-                foreach (DirectoryInfo subDirectory in dir.GetDirectories())
-                {
-                    stack.Push(new KeyValuePair<DirectoryInfo, DirectoryInfo>(subDirectory, new DirectoryInfo(Path.Combine(dDir.FullName, subDirectory.Name))));
-
-                }
-
-            }
-            catch (Exception ex)
-            {
-            }
-        }
-
-        return dirSourceDest;
-    }
-
-    public Dictionary<FileInfo, DirectoryInfo> appendDictionary(Dictionary<FileInfo, DirectoryInfo> dictA, Dictionary<FileInfo, DirectoryInfo> dictB)
-    {
-        foreach (KeyValuePair<FileInfo, DirectoryInfo> pair in dictB)
-        {
-            dictA.Add(pair.Key, pair.Value);
-        }
-        return dictA;
-    }
-
-    public Dictionary<FileInfo, DirectoryInfo> getAllFilesInDir(DirectoryInfo dir, DirectoryInfo dirDest)
-    {
-        Dictionary<FileInfo, DirectoryInfo> dict = new Dictionary<FileInfo, DirectoryInfo>();
-        foreach (FileInfo File in dir.GetFiles(filter))
-        {
-            dict.Add(File, new DirectoryInfo(Path.Combine(dirDest.FullName, File.Name)));
-
-        }
-        return dict;
-    }
-
-    private Dictionary<FileInfo, DirectoryInfo> dividiFilesInDir(DirectoryInfo dir, DirectoryInfo dirDest)
-    {
-        int filesCount = dir.GetFiles(filter).Length;
-        int contaFilePerDir = 0;
-        int contaDirPerDir = 0;
-        string tempText = string.Empty;
-        Dictionary<FileInfo, DirectoryInfo> foldersDict = new Dictionary<FileInfo, DirectoryInfo>();
-
-        DirectoryInfo destDir = null;
-        destDir = new DirectoryInfo(Path.Combine(dirDest.FullName));
-
-        foreach (FileInfo file in dir.GetFiles(filter))
-        {
-            contaFilePerDir += 1;
-
-            if (contaFilePerDir == (contaDirPerDir * filesPerFolder) + 1)
-            {
-                contaDirPerDir += 1;
-
-                if (numerazione.Progressiva.Equals(numerationType))
-                {
-                    tempText = contaDirPerDir.ToString();
-                }
-                else
-                {
-                    tempText = (contaDirPerDir * filesPerFolder).ToString();
-                }
-                int i = 0;
-                for (i = 1; i <= (counterSize - tempText.Length); i++)
-                {
-                    tempText = "0" + tempText;
-                }
-                destDir = new DirectoryInfo(Path.Combine(dirDest.FullName, suffix + tempText));
-
-
-
-            }
-
-            if (!destDir.Exists)
-            {
-                destDir.Create();
-            }
-
-            foldersDict.Add(file, destDir);
-        }
-
-        return foldersDict;
-    }
-}

ImageCatalogCS/ImageCatalog 3.csproj

@@ -1,132 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectGuid>{D11ED7B0-93E8-4F38-A142-EED72D7EE8B5}</ProjectGuid>
-    <OutputType>WinExe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>ImageCatalogCS</RootNamespace>
-    <AssemblyName>ImageCatalogCS</AssemblyName>
-    <TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <SccProjectName>SAK</SccProjectName>
-    <SccLocalPath>SAK</SccLocalPath>
-    <SccAuxPath>SAK</SccAuxPath>
-    <SccProvider>SAK</SccProvider>
-    <TargetFrameworkProfile />
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <PlatformTarget>AnyCPU</PlatformTarget>
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <PlatformTarget>AnyCPU</PlatformTarget>
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
-    <DebugSymbols>true</DebugSymbols>
-    <OutputPath>bin\x64\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <DebugType>full</DebugType>
-    <PlatformTarget>x64</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
-    <Prefer32Bit>true</Prefer32Bit>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
-    <OutputPath>bin\x64\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <Optimize>true</Optimize>
-    <DebugType>pdbonly</DebugType>
-    <PlatformTarget>x64</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
-    <Prefer32Bit>true</Prefer32Bit>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="System" />
-    <Reference Include="System.Core" />
-    <Reference Include="System.Management" />
-    <Reference Include="System.Xml.Linq" />
-    <Reference Include="System.Data.DataSetExtensions" />
-    <Reference Include="Microsoft.CSharp" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Deployment" />
-    <Reference Include="System.Drawing" />
-    <Reference Include="System.Windows.Forms" />
-    <Reference Include="System.Xml" />
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="AboutForm.cs">
-      <SubType>Form</SubType>
-    </Compile>
-    <Compile Include="AboutForm.Designer.cs">
-      <DependentUpon>AboutForm.cs</DependentUpon>
-    </Compile>
-    <Compile Include="CreaImmagineSeparateThread.cs" />
-    <Compile Include="ExifReader.cs" />
-    <Compile Include="FileHelper.cs" />
-    <Compile Include="ImageCreator.cs" />
-    <Compile Include="MainForm.cs">
-      <SubType>Form</SubType>
-    </Compile>
-    <Compile Include="MainForm.Designer.cs">
-      <DependentUpon>MainForm.cs</DependentUpon>
-    </Compile>
-    <Compile Include="PicSettings.cs" />
-    <Compile Include="Program.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="Temperature.cs" />
-    <Compile Include="XMLSettings.cs" />
-    <Compile Include="XYThreadPool.cs" />
-    <EmbeddedResource Include="AboutForm.resx">
-      <DependentUpon>AboutForm.cs</DependentUpon>
-    </EmbeddedResource>
-    <EmbeddedResource Include="MainForm.resx">
-      <DependentUpon>MainForm.cs</DependentUpon>
-    </EmbeddedResource>
-    <EmbeddedResource Include="Properties\Resources.resx">
-      <Generator>ResXFileCodeGenerator</Generator>
-      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
-      <SubType>Designer</SubType>
-    </EmbeddedResource>
-    <Compile Include="Properties\Resources.Designer.cs">
-      <AutoGen>True</AutoGen>
-      <DependentUpon>Resources.resx</DependentUpon>
-      <DesignTime>True</DesignTime>
-    </Compile>
-    <None Include="Properties\Settings.settings">
-      <Generator>SettingsSingleFileGenerator</Generator>
-      <LastGenOutput>Settings.Designer.cs</LastGenOutput>
-    </None>
-    <Compile Include="Properties\Settings.Designer.cs">
-      <AutoGen>True</AutoGen>
-      <DependentUpon>Settings.settings</DependentUpon>
-      <DesignTimeSharedInput>True</DesignTimeSharedInput>
-    </Compile>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="App.config" />
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
-  -->
-</Project>

ImageCatalogCS/MainForm.cs

@@ -1,548 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Data;
-using System.Drawing;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Windows.Forms;
-using System.IO;
-using System.Drawing.Text;
-using System.Threading;
-
-public delegate void XyThreadAdd(string Info);
-
-namespace ImageCatalogCS
-{
-    public partial class MainForm : Form
-    {
-        private bool stopAttivo;
-        private bool waterSelectColor = false;
-
-        //pool
-        private XYThreadPool myPool = new XYThreadPool();
-
-        private int contaImmaginiThread;
-
-        private int maxThreads = 15;
-        private int minThreads = 5;
-
-        public MainForm()
-        {
-            InitializeComponent();
-        }
-
-        private void setDefaults()
-        {
-            txtSorgente.Text = "";
-            txtDestinazione.Text = "";
-            TextBox3.Text = "tn_";
-            TextBox4.Text = "";
-            TextBox5.Text = "350";
-            TextBox6.Text = "350";
-            TextBox27.Text = "2240";
-            TextBox28.Text = "2240";
-            TextBox9.Text = "0";
-            TextBox11.Text = "20";
-            TextBox12.Text = "8";
-            //TextBox13.Text = ""
-            TextBox10.Text = "";
-            TextBox14.Text = "430";
-            TextBox15.Text = "430";
-            TextBox16.Text = "290";
-            txtFilePerCartella.Text = "99";
-            TextBox19.Text = "100";
-            txtSuffissoCartelle.Text = "";
-            txtCifreContatore.Text = "2";
-            TextBox25.Text = "50";
-            TextBox26.Text = "";
-            TextBox7.Text = Convert.ToString(15);
-            TextBox8.Text = Convert.ToString(5);
-            TextBox34.Text = "Yellow";
-            TextBox30.Text = "20";
-            TextBox31.Text = "6";
-            TextBox32.Text = "85";
-            TextBox33.Text = "30";
-
-
-            ComboBox1.Items.Add("Alto");
-            ComboBox1.Items.Add("Basso");
-            ComboBox1.SelectedIndex = 1;
-
-            ComboBox2.Items.Add("Sinistra");
-            ComboBox2.Items.Add("Centro");
-            ComboBox2.Items.Add("Destra");
-            ComboBox2.SelectedIndex = 1;
-
-            // Create a obejct of InstalledFontCollection
-            InstalledFontCollection InstalledFonts = new InstalledFontCollection();
-            // Gets the array of FontFamily objects associated with this FontCollection.
-            FontFamily[] fontfamilies = InstalledFonts.Families;
-
-            //   Populates font combobox with the font name
-
-            foreach (FontFamily fontFamily in fontfamilies)
-            {
-                ComboBox3.Items.Add(fontFamily.Name);
-            }
-
-            ComboBox3.Text = ComboBox3.Items[0].ToString();
-
-            ComboBox4.Items.Add("Sinistra");
-            ComboBox4.Items.Add("Centro");
-            ComboBox4.Items.Add("Destra");
-            ComboBox4.SelectedIndex = 2;
-
-            ComboBox5.Items.Add("Alto");
-            ComboBox5.Items.Add("Centro");
-            ComboBox5.Items.Add("Basso");
-            ComboBox5.SelectedIndex = 2;
-        }
-
-        private void Form1_Load(object sender, EventArgs e)
-        {
-            Application.EnableVisualStyles();
-            setDefaults();
-        }
-
-        private void btnCreaCatalogo_Click(object sender, EventArgs e)
-        {
-            DateTime timestart;
-            DateTime timeStop;
-
-            timestart = DateTime.Now;
-
-            txtFileInfo.Text = string.Empty;
-            lblFotoTotaliNum.Text = "0";
-            Label18.Text = "0";
-            Label43.Text = "-s";
-
-            maxThreads = Convert.ToInt32(TextBox7.Text);
-            minThreads = Convert.ToInt32(TextBox18.Text);
-
-            //setPicSettings(txtSorgente.Text, txtDestinazione.Text);
-            makeSettingsFromForm();
-            ProgressBar1.Minimum = 0;
-            ProgressBar1.Step = 1;
-            ProgressBar1.Value = 0;
-
-            System.Threading.Thread t1 = new System.Threading.Thread(creaCatalogoThread);
-
-
-        }
-
-        private void creaCatalogoThread()
-{
-	System.DateTime timeStart = DateTime.Now;
-	myPool.StopThreadPool();
-	myPool.StartThreadPool(minThreads, maxThreads);
-	contaImmaginiThread = 0;
-
-	//creaImmaginiWithThreadMod(txtSorgente.Text, txtDestinazione.Text)
-	//creaimmaginiWithThreadDict(txtSorgente.Text, txtDestinazione.Text);
-	ThreadPoolWorkItem ThAttivo = null;
-	//int i = 0;
-
-            // fine
-
-	
-}
-
-        private int getNumerazione()
-        {
-            int numerazione = 0;
-            if (rdbNumProgressiva.Checked)
-            {
-                numerazione = (int)FileHelper.numerazione.Progressiva;
-            }
-            else
-            {
-                numerazione = (int)FileHelper.numerazione.Files;
-            }
-            return numerazione;
-        }
-
-        private void creaimmaginiWithThreadDict(string SourcePath, string DestPath)
-{
-	Dictionary<FileInfo, DirectoryInfo> dirSourceDest = new Dictionary<FileInfo, DirectoryInfo>();
-
-	if (chkAggiornaSottodirectory.Checked & chkCreaSottocartelle.Checked) {
-		FileHelper helper = new FileHelper(Convert.ToInt32(txtFilePerCartella.Text), txtSuffissoCartelle.Text, Convert.ToInt32(txtCifreContatore.Text), getNumerazione());
-		//getfilesrecursive
-		dirSourceDest = helper.GetFilesRecursive(new DirectoryInfo(SourcePath), new DirectoryInfo(DestPath), "*.jpg");
-
-	} else if (chkAggiornaSottodirectory.Checked & !chkCreaSottocartelle.Checked) {
-
-	}
-    //else if ()
-
-	//= getDirsDict(SourcePath, DestPath)
-
-	KeyValuePair<FileInfo, DirectoryInfo> pair = default(KeyValuePair<FileInfo, DirectoryInfo>);
-
-	foreach (KeyValuePair<FileInfo, DirectoryInfo> pair_loopVariable in dirSourceDest) {
-		pair = pair_loopVariable;
-		//setLabel10Text("File: " + pair.Key.Name);
-		string b = (Convert.ToInt32(Label18.Text) + 1).ToString();
-
-		ImageCreator ClsCreaImmagine = new ImageCreator(pair.Key, pair.Value);
-		contaImmaginiThread += 1;
-		myPool.InsertWorkItem(pair.Key.Name, new XyThreadAdd(ClsCreaImmagine.CreaImmagineThread), new object[1] { pair.Key.Name }, true);
-
-	}
-
-}
-
-        private Dictionary<string, object> makeSettingsFromForm()
-        {
-            Dictionary<string, object> settingsDict = new Dictionary<string, object>();
-            settingsDict.Add("sourceDirRoot", new DirectoryInfo(txtSorgente.Text));
-            settingsDict.Add("destDirRoot", new DirectoryInfo(txtDestinazione.Text));
-
-            settingsDict.Add("DirDividiDestinazione", chkCreaSottocartelle.Checked);
-            settingsDict.Add("DirDividiNumFile", txtFilePerCartella.Text);
-            settingsDict.Add("DirDividiSuffisso", txtSuffissoCartelle.Text);
-            settingsDict.Add("DirDividiNumCifre", txtCifreContatore.Text);
-
-            settingsDict.Add("DirDividiTipoNumerazione", rdbNumProgressiva.Checked ? "Progressiva" : "Files");
-
-            //        if (rdbNumProgressiva.Checked)
-            //    settingsDict.Add("DirDividiTipoNumerazione", "Progressiva");
-            //else
-            //    settingsDict.Add("DirDividiTipoNumerazione", "Files");
-
-            // Checkbox
-            settingsDict.Add("creaMiniature", CheckBox1.Checked);
-            settingsDict.Add("aggiungiTesto", CheckBox2.Checked);
-            settingsDict.Add("grassetto", CheckBox3.Checked);
-            settingsDict.Add("logoAggiungi", CheckBox5.Checked);
-            settingsDict.Add("usaOrarioTestoApplicare", CheckBox8.Checked);
-            //settingsDict.Add("usaOrarioMiniatura", CheckBox12.Checked);
-            settingsDict.Add("fotoGrandeDimOrigina", CheckBox15.Checked);
-
-            settingsDict.Add("dimStandard", Convert.ToInt32(TextBox11.Text));
-            settingsDict.Add("dimStandardMiniatura", Convert.ToInt32(TextBox25.Text));
-
-            
-            
-
-            settingsDict.Add("usaRotazioneAutomatica", chkRotazioneAutomatica.Checked);
-            settingsDict.Add("usaForzaJpg", chkForzaJpg.Checked);
-
-            settingsDict.Add("testoNome", CheckBox17.Checked);
-            settingsDict.Add("nomeData", CheckBox16.Checked);
-
-            settingsDict.Add("testoFirmaStart", TextBox4.Text);
-            settingsDict.Add("testoFirmaStartV", TextBox29.Text);
-
-            settingsDict.Add("dataPartenza", DateTimePicker1.Value);
-            settingsDict.Add("testoOrario", TextBox18.Text);
-
-            settingsDict.Add("altezzaSmall", Convert.ToInt32(TextBox6.Text));
-            settingsDict.Add("larghezzaSmall", Convert.ToInt32(TextBox5.Text));
-
-            
-            settingsDict.Add("aggiungiScritteMiniature", RadioButton3.Checked);
-            settingsDict.Add("aggTempoGaraMin", RadioButton5.Checked);
-            settingsDict.Add("aggNumTempMin", RadioButton7.Checked);
-
-            settingsDict.Add("dimVert", Convert.ToUInt32(TextBox30.Text));
-            settingsDict.Add("margVert", Convert.ToInt32(TextBox31.Text));
-
-            settingsDict.Add("suffisso", TextBox3.Text);
-            settingsDict.Add("trasparenza", Convert.ToInt32(TextBox9.Text));
-            settingsDict.Add("ilFont", ComboBox3.SelectedItem.ToString());
-            
-
-            settingsDict.Add("posizione", ComboBox1.SelectedItem.ToString());
-            settingsDict.Add("allineamento", ComboBox2.SelectedItem.ToString());
-            settingsDict.Add("margine", Convert.ToInt32(TextBox12.Text));
-
-            settingsDict.Add("logoAltezza", Convert.ToInt32(TextBox14.Text));
-            settingsDict.Add("logoLarghezza", Convert.ToInt32(TextBox15.Text));
-
-            settingsDict.Add("fontColoreRGB", ColorTranslator.FromHtml(TextBox34.Text));
-
-            
-            settingsDict.Add("logoNomeFile", TextBox10.Text);
-            settingsDict.Add("logoTrasparenza", TextBox19.Text);
-            settingsDict.Add("logoMargine", TextBox16.Text);
-            settingsDict.Add("logoPosizioneH", ComboBox4.Text);
-            settingsDict.Add("logoPosizioneV", ComboBox5.Text);
-
-            
-            settingsDict.Add("altezzaBig", Convert.ToInt32(TextBox27.Text));
-            settingsDict.Add("larghezzaBig", Convert.ToInt32(TextBox28.Text));
-            settingsDict.Add("dimMin", Convert.ToInt32(TextBox25.Text));
-
-            settingsDict.Add("testoMin", RadioButton6.Checked);
-
-            settingsDict.Add("jpegQuality", Convert.ToInt32(TextBox32.Text));
-            settingsDict.Add("jpegQualityMin", Convert.ToInt32(TextBox33.Text));
-
-            return settingsDict;
-        }
-
-        private void setPicSettings(string SourcePath, string DestPath)
-        {
-            DirectoryInfo SourceDir = new DirectoryInfo(SourcePath);
-            DirectoryInfo DestDirStart = new DirectoryInfo(DestPath);
-            DirectoryInfo DestDir = null;
-           
-            PicSettings.directorySorgente = txtSorgente.Text;
-            PicSettings.directoryDestinazione = txtDestinazione.Text;
-
-
-            PicSettings.dimStandard = Convert.ToInt32(TextBox11.Text);
-            PicSettings.dimStandardMiniatura = Convert.ToInt32(TextBox25.Text);
-
-            //PicSettings.UsaOrarioMiniatura = CheckBox12.Checked;
-            PicSettings.UsaOrarioTestoApplicare = CheckBox8.Checked;
-            PicSettings.UsaTempoGaraTestoApplicare = CheckBox7.Checked;
-
-            PicSettings.UsaRotazioneAutomatica = chkRotazioneAutomatica.Checked;
-            PicSettings.UsaForzaJpg = chkForzaJpg.Checked;
-
-            if (CheckBox17.Checked)
-            {
-                PicSettings.TestoNome = true;
-            }
-            else
-            {
-                PicSettings.TestoNome = false;
-
-            }
-
-            if (CheckBox16.Checked)
-            {
-                PicSettings.NomeData = true;
-            }
-            else
-            {
-                PicSettings.NomeData = false;
-            }
-            PicSettings.TestoFirmaStart = TextBox4.Text;
-            PicSettings.TestoFirmaStartV = TextBox29.Text;
-
-            PicSettings.DataPartenza = DateTimePicker1.Value;
-            PicSettings.TestoOrario = TextBox18.Text;
-
-            PicSettings.AltezzaSmall = Convert.ToInt32(TextBox6.Text);
-            PicSettings.LarghezzaSmall = Convert.ToInt32(TextBox5.Text);
-
-            PicSettings.CreaMiniature = CheckBox1.Checked;
-            PicSettings.AggiungiScritteMiniature = RadioButton3.Checked;
-            PicSettings.AggTempoGaraMin = RadioButton5.Checked;
-            PicSettings.AggNumTempMin = RadioButton7.Checked;
-
-
-            PicSettings.dimVert = Convert.ToInt32(TextBox30.Text);
-            PicSettings.margVert = Convert.ToInt32(TextBox31.Text);
-
-            //PicSettings.NomeFileChild = childFile.Name
-            PicSettings.Suffisso = TextBox3.Text;
-            //PicSettings.Codice = TextBox13.Text
-
-            PicSettings.Trasparenza = Convert.ToInt32(TextBox9.Text);
-            PicSettings.IlFont = ComboBox3.SelectedItem.ToString();
-            PicSettings.Grassetto = CheckBox3.Checked;
-
-            PicSettings.Posizione = ComboBox1.SelectedItem.ToString();
-            PicSettings.Allineamento = ComboBox2.SelectedItem.ToString();
-            PicSettings.Margine = Convert.ToInt32(TextBox12.Text);
-
-            PicSettings.LogoAltezza = Convert.ToInt32(TextBox14.Text);
-            PicSettings.LogoLarghezza = Convert.ToInt32(TextBox15.Text);
-
-            PicSettings.fontColoreRGB = ColorTranslator.FromHtml(TextBox34.Text);
-
-            PicSettings.LogoAggiungi = CheckBox5.Checked;
-            PicSettings.LogoNomeFile = TextBox10.Text;
-            PicSettings.LogoTrasparenza = TextBox19.Text;
-            PicSettings.LogoMargine = TextBox16.Text;
-            PicSettings.LogoPosizioneH = ComboBox4.Text;
-            PicSettings.LogoPosizioneV = ComboBox5.Text;
-
-            PicSettings.FotoGrandeDimOrigina = CheckBox15.Checked;
-            PicSettings.AltezzaBig = Convert.ToInt32(TextBox27.Text);
-            PicSettings.LarghezzaBig = Convert.ToInt32(TextBox28.Text);
-            PicSettings.DimMin = Convert.ToInt32(TextBox25.Text);
-
-            PicSettings.TestoMin = RadioButton6.Checked;
-
-            PicSettings.jpegQuality = Convert.ToInt64(TextBox32.Text);
-            PicSettings.jpegQualityMin = Convert.ToInt64(TextBox33.Text);
-
-            PicSettings.mainForm = this;
-
-
-        }
-
-        private void makeSettingsFromFile()
-        {
-            OpenFileDialog openFileDialog = new OpenFileDialog();
-            openFileDialog.Filter = "Setup (*.xml)|*.xml|All valid files (*.*)|*.*";
-            openFileDialog.FilterIndex = 0;
-            openFileDialog.RestoreDirectory = true;
-
-            Dictionary<string, object> settingsDict = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
-
-            if (DialogResult.OK == openFileDialog.ShowDialog())
-            {
-                XMLSettings xmlSettings = new XMLSettings(openFileDialog.FileName);
-                settingsDict = xmlSettings.getParametriDict();
-
-
-                settingsDict = bindSettings(settingsDict);
-                setLogoMiniature();
-                this.Text = string.Format("Image Catalog - {0}", openFileDialog.FileName);
-                
-
-            }
-        }
-
-        private void setLogoMiniature()
-        {
-            if (File.Exists(TextBox10.Text))
-            {
-
-                PictureBox1.Image = Image.FromFile(TextBox10.Text);
-                if (PictureBox1.Image.Height >= PictureBox1.Image.Width)
-                {
-                    PictureBox1.Height = 160;
-                    PictureBox1.Width = Convert.ToInt32(160 * PictureBox1.Image.Width / PictureBox1.Image.Height);
-                }
-                else
-                {
-                    PictureBox1.Width = 224;
-                    PictureBox1.Height = Convert.ToInt32(224 * PictureBox1.Image.Height / PictureBox1.Image.Width);
-                }
-            }
-        }
-
-        private Dictionary<string, object> bindSettings(Dictionary<string, object> dict)
-        {
-
-            txtSorgente.Text = dict["dirSorgente"].ToString();
-            txtDestinazione.Text = dict["dirDestinazione"].ToString();
-            chkAggiornaSottodirectory.Checked = Convert.ToBoolean(dict["DirSottoDirectory"]);
-            
-            chkCreaSottocartelle.Checked = Convert.ToBoolean(dict["dirDividiDestinazione"]);
-            txtFilePerCartella.Text = dict["dirDividiNumFile"].ToString();
-            txtSuffissoCartelle.Text = dict["dirDividiSuffisso"].ToString();
-            txtCifreContatore.Text = dict["dirDividiNumCifre"].ToString();
-
-            if (dict["dirDividiTipoNumerazione"].ToString().ToUpper() == "PROGRESSIVA")
-                rdbNumProgressiva.Checked = true;
-            else
-                rdbNumFiles.Checked = true;
-
-            CheckBox1.Checked = Convert.ToBoolean(dict["miniatureCrea"]);
-            TextBox3.Text = dict["miniatureSuffisso"].ToString();
-            TextBox5.Text = dict["miniatureAltezza"].ToString();
-            TextBox6.Text = dict["miniatureLarghezza"].ToString();
-            RadioButton3.Checked = Convert.ToBoolean(dict["miniatureAddScritta"]);
-            RadioButton4.Checked = Convert.ToBoolean(dict["miniatureAddOrario"]);
-
-            TextBox27.Text = dict["fotoAltezza"].ToString();
-            TextBox28.Text = dict["fotoLarghezza"].ToString();
-
-            TextBox11.Text = dict["fontDimensione"].ToString();
-            TextBox25.Text = dict["fontDimensioneMiniatura"].ToString();
-            CheckBox3.Checked = Convert.ToBoolean(dict["fontBold"]);
-            ComboBox3.Text = dict["fontNome"].ToString();
-
-            TextBox4.Text = dict["testoTesto"].ToString();
-            TextBox9.Text = dict["testoTrasparente"].ToString();
-            TextBox12.Text = dict["testoMargine"].ToString();
-            ComboBox1.Text = dict["testoPosizione"].ToString();
-            ComboBox2.Text = dict["testoAllineamento"].ToString();
-
-            TextBox10.Text = dict["marchioFile"].ToString();
-            TextBox14.Text = dict["marchioAltezza"].ToString();
-            TextBox15.Text = dict["marchioLarghezza"].ToString();
-            TextBox16.Text = dict["marchioMargine"].ToString();
-            ComboBox4.Text = dict["marchioAllOrizzontale"].ToString();
-            ComboBox5.Text = dict["marchioAllVerticale"].ToString();
-            TextBox19.Text = dict["marchioTrasparenza"].ToString();
-            CheckBox5.Checked = Convert.ToBoolean(dict["MarchioAggiungi"]);
-
-            CheckBox7.Checked = Convert.ToBoolean(dict["tempoGara"]);
-            CheckBox8.Checked = Convert.ToBoolean(dict["orario"]);
-            TextBox18.Text = dict["etichettaOrario"].ToString();
-
-            chkForzaJpg.Checked = Convert.ToBoolean(dict["generaleForzaJpg"]);
-            chkRotazioneAutomatica.Checked = Convert.ToBoolean(dict["generaleRotazioneAutomatica"]);
-
-            TextBox30.Text = dict["grandezzaVerticale"].ToString();
-            TextBox31.Text = dict["margineVerticale"].ToString();
-            CheckBox15.Checked = Convert.ToBoolean(dict["dimensioniOriginali"]);
-            TextBox29.Text = dict["testoVerticale"].ToString();
-            RadioButton6.Checked = Convert.ToBoolean(dict["nomeMiniatura"]);
-            CheckBox16.Checked = Convert.ToBoolean(dict["dataFoto"]);
-            CheckBox17.Checked = Convert.ToBoolean(dict["numeroFoto"]);
-
-
-            RadioButton5.Checked = Convert.ToBoolean(dict["tempoSmall"]);
-            RadioButton7.Checked = Convert.ToBoolean(dict["numTempoSmall"]);
-
-            TextBox32.Text = dict["compressioneJpeg"].ToString();
-            TextBox33.Text = dict["compressioneJpegMiniatura"].ToString();
-
-            TextBox34.Text = dict["coloreTestoRGB"].ToString();
-
-
-
-            return dict;
-        }
-
-
-
-
-        private void caricaImpostazioniToolStripMenuItem_Click(object sender, EventArgs e)
-        {
-            makeSettingsFromFile();
-        }
-
-        private void btnStopCreazione_Click(object sender, EventArgs e)
-        {
-            
-        }
-
-        private void informazioniToolStripMenuItem_Click(object sender, EventArgs e)
-        {
-            AboutForm about = new AboutForm();
-            about.Show();
-        }
-
-        private void CheckBox2_CheckedChanged(object sender, EventArgs e)
-        {
-            if (CheckBox2.Checked)
-                panelTesto.Enabled = true;
-            else
-                panelTesto.Enabled = false;
-        }
-
-        private void CheckBox1_CheckedChanged(object sender, EventArgs e)
-        {
-            if (CheckBox1.Checked)
-                panelMiniature.Enabled = true;
-                else
-                panelMiniature.Enabled = false;
-        }
-
-      
-        
-
-
-        
-
-        
-
-        
-
-           
-        
-    }
-}

ImageCatalogCS/MainForm.resx

@@ -1,123 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <metadata name="menuStrip1.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
-    <value>17, 17</value>
-  </metadata>
-</root>

ImageCatalogCS/PicSettings.cs

@@ -1,92 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Drawing;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace ImageCatalogCS
-{
-    static class PicSettings
-    {
-        // Root
-        public static string directorySorgente { get; set; }
-        public static string directoryDestinazione { get; set; }
-
-        public static int dimVert { get; set; }
-        public static int margVert { get; set; }
-
-        public static int dimStandard { get; set; }
-        public static int dimStandardMiniatura { get; set; }
-
-        public static  bool  NomeData { get; set; }
-        public static  bool  TestoNome { get; set; }
-        public static  bool  UsaOrarioMiniatura { get; set; }
-        public static  bool  UsaOrarioTestoApplicare { get; set; }
-        public static  bool  UsaTempoGaraTestoApplicare { get; set; }
-        public static string  TestoFirmaStart { get; set; }
-        public static string  TestoFirmaStartV { get; set; }
-        public static DateTime  DataPartenza { get; set; }
-
-        public static string  TestoOrario { get; set; }
-        public static bool  UsaRotazioneAutomatica { get; set; }
-
-        public static bool  UsaForzaJpg { get; set; }
-        public static int  LarghezzaSmall { get; set; }
-
-        public static int  AltezzaSmall { get; set; }
-        public static bool  CreaMiniature { get; set; }
-        public static bool  AggiungiScritteMiniature { get; set; }
-        public static bool  AggTempoGaraMin { get; set; }
-
-        public static bool  AggNumTempMin { get; set; }
-        public static string  Suffisso { get; set; }
-
-        public static string  Codice { get; set; }
-        public static int  Trasparenza { get; set; }
-        public static string  IlFont { get; set; }
-
-        public static bool  Grassetto { get; set; }
-        public static string  Posizione { get; set; }
-        public static string  Allineamento { get; set; }
-
-        public static int  Margine { get; set; }
-        public static int  LogoAltezza { get; set; }
-
-        public static int  LogoLarghezza { get; set; }
-
-        public static Color  fontColoreRGB { get; set; }
-        public static bool  LogoAggiungi { get; set; }
-        public static string  LogoNomeFile { get; set; }
-        public static string  LogoTrasparenza { get; set; }
-        public static string  LogoMargine { get; set; }
-        public static string  LogoPosizioneH { get; set; }
-
-        public static string  LogoPosizioneV { get; set; }
-        public static bool  FotoGrandeDimOrigina { get; set; }
-        public static int  AltezzaBig { get; set; }
-        public static int  LarghezzaBig { get; set; }
-        public static DirectoryInfo  DestDir { get; set; }
-
-        public static int  DimMin { get; set; }
-
-        public static bool  TestoMin { get; set; }
-        public static bool  SecretDefault { get; set; }
-        public static bool  SecretBig { get; set; }
-
-        public static bool  SecretSmall { get; set; }
-        public static string  SecretPathSmall { get; set; }
-
-        public static string  SecretPathBig { get; set; }
-        public static long  jpegQuality { get; set; }
-
-        public static long  jpegQualityMin { get; set; }
-        public static bool FotoRuotaADestra { get; set; } // Default False
-
-        public static bool FotoRuotaASinistra { get; set; } // Default False
-
-        public static string TempMinText { get; set; } // Default ""
-        public static MainForm  mainForm { get; set; }
-    }
-}

ImageCatalogCS/Program.cs

@@ -1,22 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using System.Windows.Forms;
-
-namespace ImageCatalogCS
-{
-    static class Program
-    {
-        /// <summary>
-        /// The main entry point for the application.
-        /// </summary>
-        [STAThread]
-        static void Main()
-        {
-            Application.EnableVisualStyles();
-            Application.SetCompatibleTextRenderingDefault(false);
-            Application.Run(new MainForm());
-        }
-    }
-}

ImageCatalogCS/Properties/AssemblyInfo.cs

@@ -1,36 +0,0 @@
-using System.Reflection;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-// General Information about an assembly is controlled through the following 
-// set of attributes. Change these attribute values to modify the information
-// associated with an assembly.
-[assembly: AssemblyTitle("ImageCatalogCS")]
-[assembly: AssemblyDescription("")]
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("ImageCatalogCS")]
-[assembly: AssemblyCopyright("Copyright ©  2012")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-
-// Setting ComVisible to false makes the types in this assembly not visible 
-// to COM components.  If you need to access a type in this assembly from 
-// COM, set the ComVisible attribute to true on that type.
-[assembly: ComVisible(false)]
-
-// The following GUID is for the ID of the typelib if this project is exposed to COM
-[assembly: Guid("00b0a7a5-0de0-48e6-b0c9-ec214aa338dd")]
-
-// Version information for an assembly consists of the following four values:
-//
-//      Major Version
-//      Minor Version 
-//      Build Number
-//      Revision
-//
-// You can specify all the values or you can default the Build and Revision Numbers 
-// by using the '*' as shown below:
-// [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]

ImageCatalogCS/Properties/Resources.Designer.cs

@@ -1,63 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by a tool.
-//     Runtime Version:4.0.30319.42000
-//
-//     Changes to this file may cause incorrect behavior and will be lost if
-//     the code is regenerated.
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-namespace ImageCatalogCS.Properties {
-    using System;
-    
-    
-    /// <summary>
-    ///   A strongly-typed resource class, for looking up localized strings, etc.
-    /// </summary>
-    // This class was auto-generated by the StronglyTypedResourceBuilder
-    // class via a tool like ResGen or Visual Studio.
-    // To add or remove a member, edit your .ResX file then rerun ResGen
-    // with the /str option, or rebuild your VS project.
-    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
-    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
-    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
-    internal class Resources {
-        
-        private static global::System.Resources.ResourceManager resourceMan;
-        
-        private static global::System.Globalization.CultureInfo resourceCulture;
-        
-        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
-        internal Resources() {
-        }
-        
-        /// <summary>
-        ///   Returns the cached ResourceManager instance used by this class.
-        /// </summary>
-        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
-        internal static global::System.Resources.ResourceManager ResourceManager {
-            get {
-                if (object.ReferenceEquals(resourceMan, null)) {
-                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("ImageCatalogCS.Properties.Resources", typeof(Resources).Assembly);
-                    resourceMan = temp;
-                }
-                return resourceMan;
-            }
-        }
-        
-        /// <summary>
-        ///   Overrides the current thread's CurrentUICulture property for all
-        ///   resource lookups using this strongly typed resource class.
-        /// </summary>
-        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
-        internal static global::System.Globalization.CultureInfo Culture {
-            get {
-                return resourceCulture;
-            }
-            set {
-                resourceCulture = value;
-            }
-        }
-    }
-}

ImageCatalogCS/Properties/Resources.resx

@@ -1,117 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>

ImageCatalogCS/Properties/Settings.Designer.cs

@@ -1,26 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by a tool.
-//     Runtime Version:4.0.30319.42000
-//
-//     Changes to this file may cause incorrect behavior and will be lost if
-//     the code is regenerated.
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-namespace ImageCatalogCS.Properties {
-    
-    
-    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
-    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "17.11.0.0")]
-    internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {
-        
-        private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
-        
-        public static Settings Default {
-            get {
-                return defaultInstance;
-            }
-        }
-    }
-}

ImageCatalogCS/Properties/Settings.settings

@@ -1,7 +0,0 @@
-<?xml version='1.0' encoding='utf-8'?>
-<SettingsFile xmlns="http://schemas.microsoft.com/VisualStudio/2004/01/settings" CurrentProfile="(Default)">
-  <Profiles>
-    <Profile Name="(Default)" />
-  </Profiles>
-  <Settings />
-</SettingsFile>

ImageCatalogCS/Temperature.cs

@@ -1,32 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Management;
-
-
-
-namespace ImageCatalogCS
-{
-    public class Temperature
-    {
-        public double CurrentValue { get; set; }
-        public string InstanceName { get; set; }
-        public static List<Temperature> Temperatures
-        {
-            get
-            {
-                List<Temperature> result = new List<Temperature>();
-                ManagementObjectSearcher searcher = new ManagementObjectSearcher(@"root\WMI", "SELECT * FROM MSAcpi_ThermalZoneTemperature");
-                foreach (ManagementObject obj in searcher.Get())
-                {
-                    Double temp = Convert.ToDouble(obj["CurrentTemperature"].ToString());
-                    temp = (temp - 2732) / 10.0;
-                    result.Add(new Temperature { CurrentValue = temp, InstanceName = obj["InstanceName"].ToString() });
-                }
-                return result;
-
-            }
-        }
-    }
-}

ImageCatalogCS/XMLSettings.cs

@@ -1,208 +0,0 @@
-using Microsoft.VisualBasic;
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Data;
-using System.Diagnostics;
-using System.IO;
-
-public class XMLSettings
-{
-
-
-    private DataSet _ElencoParametri;
-
-    private string _NomeFileSetup;
-    public XMLSettings(string FileSetup)
-    {
-        _ElencoParametri = new DataSet();
-        _NomeFileSetup = FileSetup;
-
-        if (!string.IsNullOrEmpty(FileSetup))
-        {
-            CaricaParametriSetup();
-        }
-    }
-
-    public XMLSettings()
-    {
-        _ElencoParametri = new DataSet();
-        _NomeFileSetup = "";
-    }
-
-    public void CaricaParametriSetup()
-    {
-        _ElencoParametri = LeggiXmlDataSet("Setup", _NomeFileSetup, "Nome");
-    }
-
-    public void SalvaParametriSetup()
-    {
-        if (System.IO.File.Exists(_NomeFileSetup) == true)
-        {
-            File.Delete(_NomeFileSetup);
-        }
-        _ElencoParametri.WriteXml(_NomeFileSetup);
-    }
-
-    public Dictionary<string, object> getParametriDict()
-    {
-        CaricaParametriSetup();
-        Dictionary<string, object> dictParam = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
-
-        //DataRow[] LElenco = _ElencoParametri.Tables["Setup"].Select("Nome='" + NomeParametro + "'");
-        //DataTable table = _ElencoParametri.Tables["Setup"];
-
-        foreach (DataRow row in _ElencoParametri.Tables["Setup"].Rows)
-        {
-            dictParam.Add(row["Nome"].ToString(), row["Valore"]);
-        }
-
-        return dictParam;
-    }
-
-    public string LeggiParametroString(string NomeParametro)
-    {
-        string Risposta = "";
-
-        try
-        {
-            DataRow[] LElenco = _ElencoParametri.Tables["Setup"].Select("Nome='" + NomeParametro + "'");
-
-            DataRow LaRiga = null;
-            foreach (DataRow LaRiga_loopVariable in LElenco)
-            {
-                LaRiga = LaRiga_loopVariable;
-                Risposta = LaRiga["Valore"].ToString();
-            }
-        }
-        catch
-        {
-            Risposta = "";
-        }
-
-        return Risposta;
-    }
-
-    public bool LeggiParametroBoolean(string NomeParametro)
-    {
-        string Risposta = "";
-
-        try
-        {
-            DataRow[] LElenco = _ElencoParametri.Tables["Setup"].Select("Nome='" + NomeParametro + "'");
-
-            DataRow LaRiga = null;
-            foreach (DataRow LaRiga_loopVariable in LElenco)
-            {
-                LaRiga = LaRiga_loopVariable;
-                Risposta = LaRiga["Valore"].ToString();
-            }
-        }
-        catch
-        {
-            Risposta = "";
-        }
-
-        switch (Risposta.ToUpper())
-        {
-            case "TRUE":
-            case "OK":
-            case "SI":
-            case "1":
-            case "YES":
-            case "VERO":
-                return true;
-            default:
-                return false;
-        }
-    }
-
-    public void AggiornaParametro(string NomeParametro, object ValoreParametro)
-    {
-        try
-        {
-            if (_ElencoParametri.Tables["Setup"] == null)
-            {
-                DataTable TabellaTmp = new DataTable("Setup");
-                DataRow RigaTmp = null;
-
-                DataColumn LaColonna = null;
-                LaColonna = TabellaTmp.Columns.Add("Nome", System.Type.GetType("System.String"));
-                LaColonna = TabellaTmp.Columns.Add("Valore", System.Type.GetType("System.String"));
-
-                //* Aggiunge alla tabella tutte le righe
-                RigaTmp = TabellaTmp.NewRow();
-                RigaTmp["Nome"] = NomeParametro;
-                RigaTmp["Valore"] = ValoreParametro;
-                TabellaTmp.Rows.Add(RigaTmp);
-
-                _ElencoParametri.Tables.Add(TabellaTmp);
-            }
-            else
-            {
-                DataRow[] LElenco = _ElencoParametri.Tables["Setup"].Select("Nome='" + NomeParametro + "'");
-
-                if (LElenco.Length == 0)
-                {
-                    DataRow LaRiga = null;
-                    LaRiga = _ElencoParametri.Tables["Setup"].NewRow();
-                    LaRiga["Nome"] = NomeParametro;
-                    LaRiga["Valore"] = ValoreParametro;
-                    _ElencoParametri.Tables["Setup"].Rows.Add(LaRiga);
-                }
-                else
-                {
-                    LElenco[0]["Valore"] = ValoreParametro;
-                }
-            }
-
-        }
-        catch
-        {
-        }
-    }
-
-
-    private DataTable LeggiXmlDataTable(string NomeTabella, string NomeFileXml, string NomeColonnaChiave = "")
-    {
-        //* Crea e Legge il dataset dal file xml
-        System.Data.DataSet DataSetXml = new System.Data.DataSet();
-        DataSetXml.ReadXml(NomeFileXml);
-
-        //* Aggiunge il campo chiave
-        if (!string.IsNullOrEmpty(NomeColonnaChiave))
-        {
-            DataSetXml.Tables[NomeTabella].Constraints.Add(NomeColonnaChiave, DataSetXml.Tables[NomeTabella].Columns[NomeColonnaChiave], true);
-        }
-
-        //* Restituisce la risposta
-        return DataSetXml.Tables[NomeTabella];
-    }
-
-    private static DataSet LeggiXmlDataSet(string NomeTabella, string NomeFileXml, string NomeColonnaChiave = "")
-    {
-        //* Crea e Legge il dataset dal file xml
-        DataSet DataSetXml = new DataSet();
-        DataSetXml.ReadXml(NomeFileXml);
-
-        //* Aggiunge il campo chiave
-        if (!string.IsNullOrEmpty(NomeColonnaChiave))
-        {
-            DataSetXml.Tables[NomeTabella].Constraints.Add(NomeColonnaChiave, DataSetXml.Tables[NomeTabella].Columns[NomeColonnaChiave], true);
-        }
-
-        //* Restituisce la risposta
-        return DataSetXml;
-    }
-
-
-
-
-    public string NomeFileSetup
-    {
-        get { return _NomeFileSetup; }
-        set { _NomeFileSetup = value; }
-    }
-
-
-}

ImageCatalogCS/XYThreadPool.cs

@@ -1,251 +0,0 @@
-using Microsoft.VisualBasic;
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Data;
-using System.Diagnostics;
-
-using System.Threading;
-
-public delegate void ThreadErrorHandlerDelegate(ThreadPoolWorkItem oWorkItem, Exception oError);
-
-public class ThreadPoolWorkItem
-{
-    public bool m_bStoreOutput = false;
-    public string m_sName = "";
-    public Delegate m_pMethod = null;
-    public object[] m_pInput = null;
-    public object m_oOutput = null;
-    public Exception m_oException = null;
-    public ThreadPoolWorkItem()
-    {
-    }
-    public ThreadPoolWorkItem(string sName, Delegate pMethod, object[] pInput, bool bStoreOutput)
-    {
-        m_sName = sName;
-        m_pMethod = pMethod;
-        m_pInput = pInput;
-        m_bStoreOutput = bStoreOutput;
-    }
-}
-
-public class XYThreadPool
-{
-    private Hashtable m_htThreads = new Hashtable(256);
-    private int m_nMinThreadCount = 5;
-    private int m_nMaxThreadCount = 10;
-    private int m_nShutdownPause = 200;
-    private int m_nServerPause = 25;
-    private bool m_bContinue = false;
-    private static Exception m_oException = null;
-    private Queue m_qInput = new Queue(1024);
-    private Queue m_qOutput = new Queue(1024);
-    private Delegate m_delegateThreadErrorHandler = new ThreadErrorHandlerDelegate(OnThreadError);
-    private void ThreadProc()
-    {
-        while (m_bContinue)
-        {
-            object obj = null;
-            Monitor.Enter(this);
-            if (m_qInput.Count > 0)
-                obj = m_qInput.Dequeue();
-            Monitor.Exit(this);
-            if (obj == null)
-            {
-                bool bQuit = false;
-                Monitor.Enter(this);
-                if (m_htThreads.Count > m_nMinThreadCount)
-                {
-                    m_htThreads.Remove(Thread.CurrentThread.Name);
-                    bQuit = true;
-                }
-                Monitor.Exit(this);
-                if (bQuit)
-                    return;
-                Thread.Sleep(10 * m_nServerPause);
-            }
-            else
-            {
-                ThreadPoolWorkItem oWorkItem = (ThreadPoolWorkItem)obj;
-                //oWorkItem.m_oOutput = oWorkItem.m_pMethod.DynamicInvoke(oWorkItem.m_pInput)
-                try
-                {
-                    oWorkItem.m_oOutput = oWorkItem.m_pMethod.DynamicInvoke(oWorkItem.m_pInput);
-                }
-                catch (Exception oBug)
-                {
-                    if ((m_delegateThreadErrorHandler != null))
-                    {
-                        try
-                        {
-                            object[] pInput = {
-								oWorkItem,
-								oBug
-							};
-                            m_delegateThreadErrorHandler.DynamicInvoke(pInput);
-                        }
-                        catch
-                        {
-                        }
-                    }
-                }
-                if (oWorkItem.m_bStoreOutput)
-                {
-                    Monitor.Enter(m_qOutput);
-                    m_qOutput.Enqueue(oWorkItem);
-                    Monitor.Exit(m_qOutput);
-                }
-                Thread.Sleep(m_nServerPause);
-            }
-        }
-    }
-    private static void OnThreadError(ThreadPoolWorkItem oWorkItem, Exception oError)
-    {
-        if (oWorkItem == null)
-        {
-            m_oException = oError;
-        }
-        else
-        {
-            oWorkItem.m_oException = oError;
-        }
-    }
-    public void SetThreadErrorHandler(ThreadErrorHandlerDelegate pMethod)
-    {
-        Monitor.Enter(this);
-        m_delegateThreadErrorHandler = pMethod;
-        Monitor.Exit(this);
-    }
-    public void SetServerPause(int nMilliseconds)
-    {
-        Monitor.Enter(this);
-        if (nMilliseconds > 9 & nMilliseconds < 101)
-            m_nServerPause = nMilliseconds;
-        Monitor.Exit(this);
-    }
-    public void SetShutdownPause(int nMilliseconds)
-    {
-        Monitor.Enter(this);
-        m_nShutdownPause = nMilliseconds;
-        Monitor.Exit(this);
-    }
-    public Exception GetException()
-    {
-        return m_oException;
-    }
-    public void InsertWorkItem(ThreadPoolWorkItem oWorkItem)
-    {
-        try
-        {
-            Monitor.Enter(this);
-            m_qInput.Enqueue(oWorkItem);
-            if (m_bContinue && m_qInput.Count > m_htThreads.Count && m_htThreads.Count < m_nMaxThreadCount)
-            {
-                Thread th = new Thread(ThreadProc);
-                th.Name = Guid.NewGuid().ToString();
-                m_htThreads.Add(th.Name, th);
-                th.Start();
-            }
-        }
-        catch (Exception oBug)
-        {
-            m_oException = oBug;
-        }
-        finally
-        {
-            Monitor.Exit(this);
-        }
-    }
-    public void InsertWorkItem(string sName, Delegate pMethod, object[] pArgs, bool bStoreOutput)
-    {
-        InsertWorkItem(new ThreadPoolWorkItem(sName, pMethod, pArgs, bStoreOutput));
-    }
-    public ThreadPoolWorkItem ExtractWorkItem()
-    {
-        object oWorkItem = null;
-        Monitor.Enter(m_qOutput);
-        if (m_qOutput.Count > 0)
-            oWorkItem = m_qOutput.Dequeue();
-        Monitor.Exit(m_qOutput);
-        if (oWorkItem == null)
-            return null;
-        return (ThreadPoolWorkItem)oWorkItem;
-    }
-    public bool StartThreadPool(int nMinThreadCount = 5, int nMaxThreadCount = 10)
-    {
-        try
-        {
-            Monitor.Enter(this);
-            if (m_bContinue == false)
-            {
-                m_bContinue = true;
-                if (nMinThreadCount > 0)
-                {
-                    m_nMinThreadCount = nMinThreadCount;
-                }
-                if (nMaxThreadCount > m_nMinThreadCount)
-                {
-                    m_nMaxThreadCount = nMaxThreadCount;
-                }
-                else
-                {
-                    m_nMaxThreadCount = 2 * m_nMinThreadCount;
-                }
-                int i = 0;
-                for (i = 1; i <= m_nMinThreadCount; i++)
-                {
-                    Thread th = new Thread(ThreadProc);
-                    th.Name = Guid.NewGuid().ToString();
-                    m_htThreads.Add(th.Name, th);
-                    th.Start();
-                }
-            }
-            return true;
-        }
-        catch (Exception oBug)
-        {
-            m_bContinue = false;
-            m_oException = oBug;
-            return false;
-        }
-        finally
-        {
-            Monitor.Exit(this);
-        }
-    }
-    public void StopThreadPool()
-    {
-        Monitor.Enter(this);
-        m_bContinue = false;
-        Thread.Sleep(Math.Max(200, m_nShutdownPause));
-        if ((m_nShutdownPause > 0))
-        {
-            IDictionaryEnumerator dict = m_htThreads.GetEnumerator();
-            while (dict.MoveNext())
-            {
-                Thread th = (Thread)dict.Value;
-                if (th.IsAlive)
-                {
-                    try
-                    {
-                        th.Abort();
-                    }
-                    catch
-                    {
-                    }
-                }
-            }
-        }
-        m_htThreads.Clear();
-        m_qInput.Clear();
-        // m_qOutput.Clear()
-        Monitor.Exit(this);
-    }
-    public int GetThreadCount()
-    {
-        Monitor.Enter(this);
-        int nCount = m_htThreads.Count;
-        Monitor.Exit(this);
-        return nCount;
-    }
-}

ImageCatalogParallel/App.config

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<configuration>
-    <startup> 
-        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.8" />
-    </startup>
-</configuration>

ImageCatalogParallel/Form1.cs

@@ -1,20 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Data;
-using System.Drawing;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Windows.Forms;
-
-namespace ImageCatalogParallel
-{
-    public partial class Form1 : Form
-    {
-        public Form1()
-        {
-            InitializeComponent();
-        }
-    }
-}

ImageCatalogParallel/Form1.resx

@@ -1,120 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>

ImageCatalogParallel/ImageCatalogParallel.csproj

@@ -1,83 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectGuid>{0F42DA5C-2788-48BD-BACA-01625C3CFFBB}</ProjectGuid>
-    <OutputType>WinExe</OutputType>
-    <RootNamespace>ImageCatalogParallel</RootNamespace>
-    <AssemblyName>ImageCatalogParallel</AssemblyName>
-    <TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
-    <Deterministic>true</Deterministic>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <PlatformTarget>AnyCPU</PlatformTarget>
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <PlatformTarget>AnyCPU</PlatformTarget>
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="System" />
-    <Reference Include="System.Core" />
-    <Reference Include="System.Xml.Linq" />
-    <Reference Include="System.Data.DataSetExtensions" />
-    <Reference Include="Microsoft.CSharp" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Deployment" />
-    <Reference Include="System.Drawing" />
-    <Reference Include="System.Net.Http" />
-    <Reference Include="System.Windows.Forms" />
-    <Reference Include="System.Xml" />
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="Form1.cs">
-      <SubType>Form</SubType>
-    </Compile>
-    <Compile Include="Form1.Designer.cs">
-      <DependentUpon>Form1.cs</DependentUpon>
-    </Compile>
-    <Compile Include="Program.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-    <EmbeddedResource Include="Form1.resx">
-      <DependentUpon>Form1.cs</DependentUpon>
-    </EmbeddedResource>
-    <EmbeddedResource Include="Properties\Resources.resx">
-      <Generator>ResXFileCodeGenerator</Generator>
-      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
-      <SubType>Designer</SubType>
-    </EmbeddedResource>
-    <Compile Include="Properties\Resources.Designer.cs">
-      <AutoGen>True</AutoGen>
-      <DependentUpon>Resources.resx</DependentUpon>
-    </Compile>
-    <None Include="Properties\Settings.settings">
-      <Generator>SettingsSingleFileGenerator</Generator>
-      <LastGenOutput>Settings.Designer.cs</LastGenOutput>
-    </None>
-    <Compile Include="Properties\Settings.Designer.cs">
-      <AutoGen>True</AutoGen>
-      <DependentUpon>Settings.settings</DependentUpon>
-      <DesignTimeSharedInput>True</DesignTimeSharedInput>
-    </Compile>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="App.config" />
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-</Project>

ImageCatalogParallel/Program.cs

@@ -1,22 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using System.Windows.Forms;
-
-namespace ImageCatalogParallel
-{
-    static class Program
-    {
-        /// <summary>
-        /// The main entry point for the application.
-        /// </summary>
-        [STAThread]
-        static void Main()
-        {
-            Application.EnableVisualStyles();
-            Application.SetCompatibleTextRenderingDefault(false);
-            Application.Run(new Form1());
-        }
-    }
-}

ImageCatalogParallel/Properties/AssemblyInfo.cs

@@ -1,36 +0,0 @@
-using System.Reflection;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-// General Information about an assembly is controlled through the following
-// set of attributes. Change these attribute values to modify the information
-// associated with an assembly.
-[assembly: AssemblyTitle("ImageCatalogParallel")]
-[assembly: AssemblyDescription("")]
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("ImageCatalogParallel")]
-[assembly: AssemblyCopyright("Copyright ©  2021")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-
-// Setting ComVisible to false makes the types in this assembly not visible
-// to COM components.  If you need to access a type in this assembly from
-// COM, set the ComVisible attribute to true on that type.
-[assembly: ComVisible(false)]
-
-// The following GUID is for the ID of the typelib if this project is exposed to COM
-[assembly: Guid("0f42da5c-2788-48bd-baca-01625c3cffbb")]
-
-// Version information for an assembly consists of the following four values:
-//
-//      Major Version
-//      Minor Version
-//      Build Number
-//      Revision
-//
-// You can specify all the values or you can default the Build and Revision Numbers
-// by using the '*' as shown below:
-// [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]

ImageCatalogParallel/Properties/Resources.Designer.cs

@@ -1,70 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by a tool.
-//     Runtime Version:4.0.30319.42000
-//
-//     Changes to this file may cause incorrect behavior and will be lost if
-//     the code is regenerated.
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-
-namespace ImageCatalogParallel.Properties
-{
-    /// <summary>
-    ///   A strongly-typed resource class, for looking up localized strings, etc.
-    /// </summary>
-    // This class was auto-generated by the StronglyTypedResourceBuilder
-    // class via a tool like ResGen or Visual Studio.
-    // To add or remove a member, edit your .ResX file then rerun ResGen
-    // with the /str option, or rebuild your VS project.
-    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
-    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
-    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
-    internal class Resources
-    {
-
-        private static global::System.Resources.ResourceManager resourceMan;
-
-        private static global::System.Globalization.CultureInfo resourceCulture;
-
-        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
-        internal Resources()
-        {
-        }
-
-        /// <summary>
-        ///   Returns the cached ResourceManager instance used by this class.
-        /// </summary>
-        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
-        internal static global::System.Resources.ResourceManager ResourceManager
-        {
-            get
-            {
-                if ((resourceMan == null))
-                {
-                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("ImageCatalogParallel.Properties.Resources", typeof(Resources).Assembly);
-                    resourceMan = temp;
-                }
-                return resourceMan;
-            }
-        }
-
-        /// <summary>
-        ///   Overrides the current thread's CurrentUICulture property for all
-        ///   resource lookups using this strongly typed resource class.
-        /// </summary>
-        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
-        internal static global::System.Globalization.CultureInfo Culture
-        {
-            get
-            {
-                return resourceCulture;
-            }
-            set
-            {
-                resourceCulture = value;
-            }
-        }
-    }
-}

ImageCatalogParallel/Properties/Resources.resx

@@ -1,117 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>

ImageCatalogParallel/Properties/Settings.Designer.cs

@@ -1,29 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by a tool.
-//     Runtime Version:4.0.30319.42000
-//
-//     Changes to this file may cause incorrect behavior and will be lost if
-//     the code is regenerated.
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-
-namespace ImageCatalogParallel.Properties
-{
-    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
-    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")]
-    internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase
-    {
-
-        private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
-
-        public static Settings Default
-        {
-            get
-            {
-                return defaultInstance;
-            }
-        }
-    }
-}

ImageCatalogParallel/Properties/Settings.settings

@@ -1,7 +0,0 @@
-<?xml version='1.0' encoding='utf-8'?>
-<SettingsFile xmlns="http://schemas.microsoft.com/VisualStudio/2004/01/settings" CurrentProfile="(Default)">
-  <Profiles>
-    <Profile Name="(Default)" />
-  </Profiles>
-  <Settings />
-</SettingsFile>

MaddoShared.ImageSharpTests/Helpers/CreatorFactory.cs

@@ -0,0 +1,44 @@
+using System.IO;
+using Microsoft.Extensions.Logging.Abstractions;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace MaddoShared.ImageSharpTests.Helpers
+{
+    public static class CreatorFactory
+    {
+        public static MaddoShared.PicSettings CreateDefaultPicSettings()
+        {
+            return new MaddoShared.PicSettings
+            {
+                DimStandard = 48,
+                DimStandardMiniatura = 12,
+                LarghezzaSmall = 150,
+                AltezzaSmall = 150,
+                LarghezzaBig = 800,
+                AltezzaBig = 600,
+                Trasparenza = 0,
+                IlFont = "Arial",
+                Grassetto = false,
+                Posizione = "CENTRO",
+                Allineamento = "CENTRO",
+                Margine = 10,
+                MargVert = 10,
+                TestoMin = false,
+                AggNumTempMin = false,
+                CreaMiniature = false,
+                LogoAggiungi = false,
+                LogoAltezza = 100,
+                LogoLarghezza = 100,
+                LogoMargine = "0",
+                JpegQuality = 90,
+                JpegQualityMin = 75,
+            };
+        }
+
+        public static MaddoShared.ImageCreatorImageSharp CreateImageCreator(MaddoShared.PicSettings settings)
+        {
+            var logger = NullLogger<MaddoShared.ImageCreatorImageSharp>.Instance;
+            return new MaddoShared.ImageCreatorImageSharp(settings, logger);
+        }
+    }
+}

MaddoShared.ImageSharpTests/Helpers/PixelInspector.cs

@@ -0,0 +1,40 @@
+using System;
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace MaddoShared.ImageSharpTests.Helpers
+{
+    public static class PixelInspector
+    {
+        public static int CountNonBackgroundPixels(string path, int x, int y, int width, int height, Rgba32 background, int tolerance = 0)
+        {
+            using var img = SixLabors.ImageSharp.Image.Load<Rgba32>(path);
+            var bx = Math.Max(0, x);
+            var by = Math.Max(0, y);
+            var bw = Math.Min(width, img.Width - bx);
+            var bh = Math.Min(height, img.Height - by);
+            if (bw <= 0 || bh <= 0) return 0;
+
+            int count = 0;
+            img.ProcessPixelRows(accessor =>
+            {
+                for (int yy = by; yy < by + bh; yy++)
+                {
+                    var row = accessor.GetRowSpan(yy);
+                    for (int xx = bx; xx < bx + bw; xx++)
+                    {
+                        var p = row[xx];
+                        if (!IsApproximatelyEqual(p, background, tolerance)) count++;
+                    }
+                }
+            });
+
+            return count;
+        }
+
+        private static bool IsApproximatelyEqual(Rgba32 a, Rgba32 b, int tol)
+        {
+            return Math.Abs(a.R - b.R) <= tol && Math.Abs(a.G - b.G) <= tol && Math.Abs(a.B - b.B) <= tol && Math.Abs(a.A - b.A) <= tol;
+        }
+    }
+}

MaddoShared.ImageSharpTests/Helpers/TempWorkspace.cs

@@ -0,0 +1,33 @@
+using System;
+using System.IO;
+
+namespace MaddoShared.ImageSharpTests.Helpers
+{
+    public sealed class TempWorkspace : IDisposable
+    {
+        public DirectoryInfo Root { get; }
+        public DirectoryInfo SourceDir { get; }
+        public DirectoryInfo DestDir { get; }
+
+        public TempWorkspace()
+        {
+            var root = Path.Combine(Path.GetTempPath(), "MaddoShared.ImageSharpTests", Guid.NewGuid().ToString("N"));
+            Root = Directory.CreateDirectory(root);
+            SourceDir = Directory.CreateDirectory(Path.Combine(Root.FullName, "Source"));
+            DestDir = Directory.CreateDirectory(Path.Combine(Root.FullName, "Dest"));
+        }
+
+        public void Dispose()
+        {
+            try
+            {
+                if (Root.Exists)
+                    Root.Delete(true);
+            }
+            catch
+            {
+                // best-effort cleanup
+            }
+        }
+    }
+}

MaddoShared.ImageSharpTests/Helpers/TestImageFactory.cs

@@ -0,0 +1,45 @@
+using System.IO;
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Processing;
+using SixLabors.ImageSharp.Formats.Jpeg;
+using SixLabors.ImageSharp.Metadata.Profiles.Exif;
+
+namespace MaddoShared.ImageSharpTests.Helpers
+{
+    public static class TestImageFactory
+    {
+        public static string CreateSolidJpeg(string directory, string fileName, int width, int height, Rgba32 color)
+        {
+            Directory.CreateDirectory(directory);
+            var path = Path.Combine(directory, fileName);
+            using var img = new Image<Rgba32>(width, height, color);
+            var encoder = new JpegEncoder { Quality = 90 };
+            img.Save(path, encoder);
+            return path;
+        }
+
+        public static string CreateSolidPng(string directory, string fileName, int width, int height, Rgba32 color)
+        {
+            Directory.CreateDirectory(directory);
+            var path = Path.Combine(directory, fileName);
+            using var img = new Image<Rgba32>(width, height, color);
+            img.SaveAsPng(path);
+            return path;
+        }
+
+        public static string CreateJpegWithExifOrientation(string directory, string fileName, int width, int height, Rgba32 color, ushort orientation)
+        {
+            Directory.CreateDirectory(directory);
+            var path = Path.Combine(directory, fileName);
+            using var img = new Image<Rgba32>(width, height, color);
+            // Add EXIF orientation
+            var profile = new ExifProfile();
+            profile.SetValue(ExifTag.Orientation, orientation);
+            img.Metadata.ExifProfile = profile;
+            var encoder = new JpegEncoder { Quality = 90 };
+            img.Save(path, encoder);
+            return path;
+        }
+    }
+}

MaddoShared.ImageSharpTests/MaddoShared.ImageSharpTests.csproj

@@ -0,0 +1,27 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
+    <PackageReference Include="MSTest.TestAdapter" Version="4.1.0" />
+    <PackageReference Include="MSTest.TestFramework" Version="4.1.0" />
+    <PackageReference Include="NSubstitute" Version="5.3.0" />
+    <PackageReference Include="Shouldly" Version="4.3.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.3" />
+    <PackageReference Include="SixLabors.ImageSharp" Version="3.1.12" />
+    <PackageReference Include="SixLabors.ImageSharp.Drawing" Version="2.1.7" />
+    <PackageReference Include="SixLabors.Fonts" Version="2.1.3" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MaddoShared\MaddoShared.csproj" />
+  </ItemGroup>
+
+</Project>

MaddoShared.ImageSharpTests/Tests/ImageResizingTests.cs

@@ -0,0 +1,44 @@
+using System.IO;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using SixLabors.ImageSharp.PixelFormats;
+using MaddoShared.ImageSharpTests.Helpers;
+using Shouldly;
+
+namespace MaddoShared.ImageSharpTests.Tests
+{
+    [TestClass]
+    public class ImageResizingTests
+    {
+        [TestMethod]
+        public async Task BigImageResizesRespectSettings()
+        {
+            using var ws = new TempWorkspace();
+
+            // create a large input image
+            var inputPath = TestImageFactory.CreateSolidJpeg(ws.SourceDir.FullName, "input.jpg", 1600, 1200, new Rgba32(200, 200, 200, 255));
+
+            var pic = CreatorFactory.CreateDefaultPicSettings();
+            pic.LarghezzaBig = 800;
+            pic.AltezzaBig = 600;
+            pic.CreaMiniature = false;
+
+            var svc = CreatorFactory.CreateImageCreator(pic);
+
+            var state = new MaddoShared.ImageState
+            {
+                WorkFile = new FileInfo(inputPath),
+                DestDir = ws.DestDir,
+                SourceDir = ws.SourceDir
+            };
+
+            await svc.CreateImageAsync(state, null);
+
+            var outPath = Path.Combine(ws.DestDir.FullName, state.NomeFileBig);
+            using var outImg = SixLabors.ImageSharp.Image.Load<Rgba32>(outPath);
+
+            outImg.Width.ShouldBe(800);
+            outImg.Height.ShouldBe(600);
+        }
+    }
+}

MaddoShared.ImageSharpTests/Tests/TextPositioningTests.cs

@@ -0,0 +1,51 @@
+using System.IO;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using SixLabors.ImageSharp.PixelFormats;
+using MaddoShared.ImageSharpTests.Helpers;
+using Shouldly;
+
+namespace MaddoShared.ImageSharpTests.Tests
+{
+    [TestClass]
+    public class TextPositioningTests
+    {
+        [TestMethod]
+        public async Task TextAtBottom_IncreasesNonBackgroundPixelCountInBottomBand()
+        {
+            using var ws = new TempWorkspace();
+
+            // create white background input
+            var inputPath = TestImageFactory.CreateSolidJpeg(ws.SourceDir.FullName, "input.jpg", 800, 600, new Rgba32(255, 255, 255, 255));
+
+            var pic = CreatorFactory.CreateDefaultPicSettings();
+            pic.Posizione = "BASSO";
+            pic.DimStandard = 48; // big text
+            pic.TestoFirmaStart = "SAMPLE TEXT";
+            pic.CreaMiniature = false;
+
+            var svc = CreatorFactory.CreateImageCreator(pic);
+
+            var state = new MaddoShared.ImageState
+            {
+                WorkFile = new FileInfo(inputPath),
+                DestDir = ws.DestDir,
+                SourceDir = ws.SourceDir
+            };
+
+            await svc.CreateImageAsync(state, null);
+
+            var outPath = Path.Combine(ws.DestDir.FullName, state.NomeFileBig);
+
+            // bottom band (lower 25% of image)
+            var bottomY = (int)(600 * 0.75);
+            var bottomCount = PixelInspector.CountNonBackgroundPixels(outPath, 0, bottomY, 800, 600 - bottomY, new Rgba32(255, 255, 255, 255), tolerance: 10);
+
+            // top band (upper 25%)
+            var topCount = PixelInspector.CountNonBackgroundPixels(outPath, 0, 0, 800, (int)(600 * 0.25), new Rgba32(255, 255, 255, 255), tolerance: 10);
+
+            (bottomCount > 50).ShouldBeTrue($"Expected text pixels in bottom band, found {bottomCount}");
+            (bottomCount > topCount).ShouldBeTrue("Expected more non-background pixels at bottom than top");
+        }
+    }
+}

MaddoShared.Tests/DataModelCharacterizationTests.cs

@@ -0,0 +1,172 @@
+using System;
+using System.Threading.Tasks;
+using ImageCatalog_2;
+using ImageCatalog_2.Services;
+using MaddoShared;
+using Microsoft.Extensions.Logging;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NSubstitute;
+using Shouldly;
+
+namespace MaddoShared.Tests;
+
+[TestClass]
+public class DataModelCharacterizationTests
+{
+    [TestMethod]
+    public void SelectSourceFolderCommand_RaisesEvent()
+    {
+        var model = CreateModel();
+        var raised = false;
+        model.SelectSourceFolderRequested += (_, _) => raised = true;
+
+        model.SelectSourceFolderCommand.Execute(null);
+
+        raised.ShouldBeTrue();
+    }
+
+    [TestMethod]
+    public async Task SaveSettingsToFileAsync_DelegatesToSettingsService()
+    {
+        var settingsService = Substitute.For<ISettingsService>();
+        settingsService
+            .SaveSettingsAsync(Arg.Any<string>(), Arg.Any<object>())
+            .Returns(Task.CompletedTask);
+
+        var model = CreateModel(settingsService: settingsService);
+
+        await model.SaveSettingsToFileAsync("settings.xml");
+
+        await settingsService.Received(1)
+            .SaveSettingsAsync("settings.xml", model);
+    }
+
+    [TestMethod]
+    public async Task LoadSettingsFromFileAsync_DelegatesToSettingsService()
+    {
+        var settingsService = Substitute.For<ISettingsService>();
+        settingsService
+            .LoadSettingsAsync(Arg.Any<string>(), Arg.Any<object>())
+            .Returns(Task.CompletedTask);
+
+        var model = CreateModel(settingsService: settingsService);
+
+        await model.LoadSettingsFromFileAsync("settings.xml");
+
+        await settingsService.Received(1)
+            .LoadSettingsAsync("settings.xml", model);
+    }
+
+    [TestMethod]
+    public void ThumbnailOptionIndex_UpdatesAuthoritativeThumbnailState()
+    {
+        var model = CreateModel();
+
+        model.ThumbnailOptionIndex = (int)DataModel.ThumbnailOptionEnum.RaceTime;
+
+        model.ThumbnailOption.ShouldBe(DataModel.ThumbnailOptionEnum.RaceTime);
+        model.AddRaceTimeToThumbnails.ShouldBeTrue();
+        model.ThumbnailMode.ShouldBe("RaceTime");
+    }
+
+    [TestMethod]
+    public void ProcessingChildChange_RaisesDataModelPropertyChanged()
+    {
+        var model = CreateModel();
+        string? changed = null;
+        model.PropertyChanged += (_, args) => changed = args.PropertyName;
+
+        model.Processing.SpeedCounter = "12.00 f/s";
+
+        changed.ShouldBe(nameof(DataModel.SpeedCounter));
+        model.SpeedCounter.ShouldBe("12.00 f/s");
+    }
+
+    [TestMethod]
+    public void PathsNormalize_UpdatesFlattenedSourceAndDestination()
+    {
+        var model = CreateModel();
+        model.SourcePath = "\"C:/input\"";
+        model.DestinationPath = "C:/output";
+
+        model.Paths.NormalizePaths();
+
+        model.SourcePath.ShouldBe($"C:{System.IO.Path.DirectorySeparatorChar}input{System.IO.Path.DirectorySeparatorChar}");
+        model.DestinationPath.ShouldBe($"C:{System.IO.Path.DirectorySeparatorChar}output{System.IO.Path.DirectorySeparatorChar}");
+    }
+
+    [TestMethod]
+    public void AiChildChange_RaisesDataModelPropertyChanged()
+    {
+        var model = CreateModel();
+        string? changed = null;
+        model.PropertyChanged += (_, args) => changed = args.PropertyName;
+
+        model.Ai.ModelsFolderPath = "K:/models";
+
+        changed.ShouldBe(nameof(DataModel.ModelsFolderPath));
+        model.ModelsFolderPath.ShouldBe("K:/models");
+    }
+
+    [TestMethod]
+    public void RaceUploadChildChange_RaisesDataModelPropertyChanged()
+    {
+        var model = CreateModel();
+        string? changed = null;
+        model.PropertyChanged += (_, args) => changed = args.PropertyName;
+
+        model.RaceUpload.ApiLogin = "admin";
+
+        changed.ShouldBe(nameof(DataModel.ApiLogin));
+        model.ApiLogin.ShouldBe("admin");
+    }
+
+    [TestMethod]
+    public void VisualChildChange_RaisesDataModelPropertyChanged()
+    {
+        var model = CreateModel();
+        string? changed = null;
+        model.PropertyChanged += (_, args) => changed = args.PropertyName;
+
+        model.Visual.FontSize = 42;
+
+        changed.ShouldBe(nameof(DataModel.FontSize));
+        model.FontSize.ShouldBe(42);
+    }
+
+    private static DataModel CreateModel(
+        ISettingsService? settingsService = null,
+        ITestService? testService = null)
+    {
+        var mapper = Substitute.For<AutoMapper.IMapper>();
+        var picSettings = new PicSettings();
+
+        var imageCreator = Substitute.For<IImageCreator>();
+        imageCreator
+            .CreateImageAsync(Arg.Any<ImageState>(), Arg.Any<byte[]?>())
+            .Returns(Task.CompletedTask);
+
+        var imageCreationService = new ImageCreationService(
+            Substitute.For<ILogger<ImageCreationService>>(),
+            picSettings,
+            imageCreator);
+
+        var imageProcessingCoordinator = new ImageProcessingCoordinator(
+            imageCreationService,
+            Substitute.For<ILogger<ImageProcessingCoordinator>>());
+
+        var aiExtractionService = new AiExtractionService(
+            Substitute.For<ILogger<AiExtractionService>>());
+
+        return new DataModel(
+            testService ?? Substitute.For<ITestService>(),
+            settingsService ?? Substitute.For<ISettingsService>(),
+            imageCreationService,
+            aiExtractionService,
+            imageProcessingCoordinator,
+            picSettings,
+            mapper,
+            Substitute.For<ILogger<DataModel>>(),
+            versionProvider: null);
+    }
+}

MaddoShared.Tests/ImageCreatorSharpTests.cs

@@ -5,8 +5,8 @@ using System.IO;
 using System.Reflection;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Microsoft.Extensions.Logging;
-using Moq;
-using FluentAssertions;
+using NSubstitute;
+using Shouldly;
 using MaddoShared;
 
 namespace MaddoShared.Tests
@@ -37,7 +37,7 @@ namespace MaddoShared.Tests
 
             customize?.Invoke(settings);
 
-            var logger = new Mock<ILogger<ImageCreatorGDI>>().Object;
+            var logger = Substitute.For<ILogger<ImageCreatorGDI>>();
             return new ImageCreatorGDI(settings, logger);
         }
 
@@ -46,12 +46,12 @@ namespace MaddoShared.Tests
         {
             var svc = CreateService();
             var mi = svc.GetType().GetMethod("CalculateThumbnailSize", BindingFlags.NonPublic | BindingFlags.Instance);
-            mi.Should().NotBeNull();
+            mi.ShouldNotBeNull();
 
             var size = (Size)mi.Invoke(svc, new object[] { 400, 200, 200, "Larghezza" });
 
-            size.Width.Should().Be(200);
-            size.Height.Should().Be(100);
+            size.Width.ShouldBe(200);
+            size.Height.ShouldBe(100);
         }
 
         [TestMethod]
@@ -59,12 +59,12 @@ namespace MaddoShared.Tests
         {
             var svc = CreateService();
             var mi = svc.GetType().GetMethod("CalculateThumbnailSize", BindingFlags.NonPublic | BindingFlags.Instance);
-            mi.Should().NotBeNull();
+            mi.ShouldNotBeNull();
 
             var size = (Size)mi.Invoke(svc, new object[] { 200, 400, 200, "Altezza" });
 
-            size.Width.Should().Be(100);
-            size.Height.Should().Be(200);
+            size.Width.ShouldBe(100);
+            size.Height.ShouldBe(200);
         }
 
         [TestMethod]
@@ -72,13 +72,13 @@ namespace MaddoShared.Tests
         {
             var svc = CreateService();
             var mi = svc.GetType().GetMethod("IsSameDirectory", BindingFlags.NonPublic | BindingFlags.Instance);
-            mi.Should().NotBeNull();
+            mi.ShouldNotBeNull();
 
             bool same = (bool)mi.Invoke(svc, new object[] { @"C:\Temp", @"c:\temp" });
-            same.Should().BeTrue();
+            same.ShouldBeTrue();
 
             bool notSame = (bool)mi.Invoke(svc, new object[] { @"C:\TempA", @"c:\temp" });
-            notSame.Should().BeFalse();
+            notSame.ShouldBeFalse();
         }
 
         [TestMethod]
@@ -86,12 +86,12 @@ namespace MaddoShared.Tests
         {
             var svc = CreateService(s => s.Codice = "_X");
             var mi = svc.GetType().GetMethod("UpdateFilenameWithCode", BindingFlags.NonPublic | BindingFlags.Instance);
-            mi.Should().NotBeNull();
+            mi.ShouldNotBeNull();
 
             var state = new ImageState { NomeFileSmall = "photo123.jpg" };
             mi.Invoke(svc, new object[] { state });
 
-            state.NomeFileSmall.Should().Be("photo123_X.jpg");
+            state.NomeFileSmall.ShouldBe("photo123_X.jpg");
         }
 
         [DataTestMethod]
@@ -103,16 +103,16 @@ namespace MaddoShared.Tests
             var svc = CreateService(s => { s.Allineamento = alignment; s.Margine = 20; });
 
             var mi = svc.GetType().GetMethod("CalculateHorizontalAlignment", BindingFlags.NonPublic | BindingFlags.Instance);
-            mi.Should().NotBeNull();
+            mi.ShouldNotBeNull();
 
             var center = (float)mi.Invoke(svc, new object[] { 800, 100f });
 
             if (alignment == "SINISTRA")
-                center.Should().BeInRange(0f, 400f, "Expected left alignment range");
+                center.ShouldBeInRange(0f, 400f);
             if (alignment == "DESTRA")
-                center.Should().BeInRange(400f, 800f, "Expected right alignment range");
+                center.ShouldBeInRange(400f, 800f);
             if (alignment == "CENTRO")
-                center.Should().BeApproximately(800 / 2f, 0.0001f);
+                center.ShouldBe(800 / 2f, 0.0001f);
         }
 
         [TestMethod]
@@ -120,14 +120,14 @@ namespace MaddoShared.Tests
         {
             var svc = CreateService(s => s.Posizione = "ALTO");
             var mi = svc.GetType().GetMethod("SetVerticalPosition", BindingFlags.NonPublic | BindingFlags.Instance);
-            mi.Should().NotBeNull();
+            mi.ShouldNotBeNull();
 
             var state = new ImageState();
 
             // ALTO
             mi.Invoke(svc, new object[] { 500, 20f, state });
-            state.YPosFromBottom1.Should().Be(10f);
-            state.YPosFromBottom4.Should().Be(10f);
+            state.YPosFromBottom1.ShouldBe(10f);
+            state.YPosFromBottom4.ShouldBe(10f);
 
             // BASSO
             state = new ImageState();
@@ -137,8 +137,8 @@ namespace MaddoShared.Tests
 
             var expected1 = (float)(200 - 20 - (200 * 10 / 100.0));
             var expected4 = (float)(200 - 20 - (200 * 5 / 100.0));
-            state.YPosFromBottom1.Should().BeApproximately(expected1, 0.001f);
-            state.YPosFromBottom4.Should().BeApproximately(expected4, 0.001f);
+            state.YPosFromBottom1.ShouldBe(expected1, 0.001f);
+            state.YPosFromBottom4.ShouldBe(expected4, 0.001f);
         }
 
         [TestMethod]
@@ -146,7 +146,7 @@ namespace MaddoShared.Tests
         {
             var svc = CreateService();
             var mi = svc.GetType().GetMethod("FormatTimeText", BindingFlags.NonPublic | BindingFlags.Instance);
-            mi.Should().NotBeNull();
+            mi.ShouldNotBeNull();
 
             var state = new ImageState
             {
@@ -156,13 +156,13 @@ namespace MaddoShared.Tests
                 DataFoto = new DateTime(2024, 01, 01, 11, 59, 0)
             };
             var withoutName = (string)mi.Invoke(svc, new object[] { state, false });
-            withoutName.Should().StartWith(Environment.NewLine);
-            withoutName.Should().Contain("T:");
+            withoutName.ShouldStartWith(Environment.NewLine);
+            withoutName.ShouldContain("T:");
 
             var withName = (string)mi.Invoke(svc, new object[] { state, true });
-            withName.Should().Contain("file.jpg");
-            withName.Should().Contain("T:");
-            withName.Should().Contain(Environment.NewLine);
+            withName.ShouldContain("file.jpg");
+            withName.ShouldContain("T:");
+            withName.ShouldContain(Environment.NewLine);
         }
 
         [TestMethod]
@@ -170,18 +170,18 @@ namespace MaddoShared.Tests
         {
             var svc = CreateService();
             var miPrep = svc.GetType().GetMethod("PrepareSignatureText", BindingFlags.NonPublic | BindingFlags.Instance);
-            miPrep.Should().NotBeNull();
+            miPrep.ShouldNotBeNull();
 
             var state = new ImageState { NomeFileBig = "bigname.jpg" };
 
             svc = CreateService(s => s.TestoMin = true);
             miPrep.Invoke(svc, new object[] { state });
-            state.TestoFirmaPiccola.Should().Be("bigname.jpg");
+            state.TestoFirmaPiccola.ShouldBe("bigname.jpg");
 
             state.TestoFirmaPiccola = "";
             svc = CreateService(s => { s.TestoMin = false; s.AggNumTempMin = true; });
             miPrep.Invoke(svc, new object[] { state });
-            state.TestoFirmaPiccola.Should().Be("bigname.jpg ");
+            state.TestoFirmaPiccola.ShouldBe("bigname.jpg ");
         }
 
         [TestMethod]
@@ -189,15 +189,15 @@ namespace MaddoShared.Tests
         {
             var svc = CreateService(s => { s.UsaOrarioMiniatura = false; s.TestoMin = false; s.AggTempoGaraMin = false; s.AggNumTempMin = false; });
             var mi = svc.GetType().GetMethod("ShouldRenderText", BindingFlags.NonPublic | BindingFlags.Instance);
-            mi.Should().NotBeNull();
+            mi.ShouldNotBeNull();
 
             var res = (bool)mi.Invoke(svc, Array.Empty<object>());
-            res.Should().BeFalse();
+            res.ShouldBeFalse();
 
             svc = CreateService(s => s.TestoMin = true);
             mi = svc.GetType().GetMethod("ShouldRenderText", BindingFlags.NonPublic | BindingFlags.Instance);
             res = (bool)mi.Invoke(svc, Array.Empty<object>());
-            res.Should().BeTrue();
+            res.ShouldBeTrue();
         }
 
         [TestMethod]
@@ -209,24 +209,29 @@ namespace MaddoShared.Tests
             using var g = Graphics.FromImage(bmp);
 
             var miFind = svc.GetType().GetMethod("FindBestFontSize", BindingFlags.NonPublic | BindingFlags.Instance);
-            miFind.Should().NotBeNull();
+            miFind.ShouldNotBeNull();
 
             int best = (int)miFind.Invoke(svc, new object[] { g, "A very long text that won't fit", "Arial", 40, false, 50, 5 });
-            best.Should().BeInRange(5, 40);
-
-            var miAdjust = svc.GetType().GetMethod("AdjustFontToFitWidth", BindingFlags.NonPublic | BindingFlags.Instance);
-            miAdjust.Should().NotBeNull();
+            best.ShouldBeInRange(5, 40);
 
+            // The helper AdjustFontToFitWidth was in an earlier refactor; replicate its logic here
             var imageState = new ImageState { DimensioneStandardMiniatura = 30, TestoFirmaPiccola = "A very long test string" };
             var initialFont = new Font("Arial", imageState.DimensioneStandardMiniatura);
             var textSize = g.MeasureString(imageState.TestoFirmaPiccola, initialFont);
 
-            object[] parameters = new object[] { g, 50, imageState, textSize };
-            miAdjust.Invoke(svc, parameters);
+            int tempFontSize = imageState.DimensioneStandardMiniatura;
+            while ((textSize.Width > 50) && tempFontSize > 5)
+            {
+                tempFontSize = (tempFontSize > 20) ? tempFontSize - 5 : tempFontSize - 1;
+                using var tempFont = new Font("Arial", tempFontSize);
+                textSize = g.MeasureString(imageState.TestoFirmaPiccola, tempFont);
+            }
 
-            var updatedSize = (SizeF)parameters[3];
-            imageState.DimensioneStandardMiniatura.Should().BeLessThanOrEqualTo(30);
-            (updatedSize.Width <= 50 || imageState.DimensioneStandardMiniatura <= 5).Should().BeTrue();
+            var updatedSize = textSize;
+            imageState.DimensioneStandardMiniatura = tempFontSize;
+
+            imageState.DimensioneStandardMiniatura.ShouldBeLessThanOrEqualTo(30);
+            (updatedSize.Width <= 50 || imageState.DimensioneStandardMiniatura <= 5).ShouldBeTrue();
         }
     }
 }

MaddoShared.Tests/MaddoShared.Tests.csproj

@@ -15,13 +15,14 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Moq" Version="4.20.72" />
-    <PackageReference Include="FluentAssertions" Version="8.8.0" />
+    <PackageReference Include="NSubstitute" Version="5.3.0" />
+    <PackageReference Include="Shouldly" Version="4.3.0" />
     <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.3" />
     <PackageReference Include="System.Drawing.Common" Version="10.0.3" />
   </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\imagecatalog\ImageCatalog 2.csproj" />
     <ProjectReference Include="..\MaddoShared\MaddoShared.csproj" />
   </ItemGroup>
 

MaddoShared.backup/FileData.cs

@@ -1,27 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace MaddoShared
-{
-    public class FileData
-    {
-        /// <summary>
-        /// Il file originale
-        /// </summary>
-        public FileInfo File { get; set; }
-        /// <summary>
-        /// La cartella di destinazione
-        /// </summary>
-        public DirectoryInfo Directory { get; set; }
-
-        public FileData(FileInfo newFile, DirectoryInfo newDirectory)
-        {
-            this.File = newFile;
-            this.Directory = newDirectory;
-        }
-    }
-}

MaddoShared.backup/FileHelperSharp.cs

@@ -1,116 +0,0 @@
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace MaddoShared
-{
-    public class FileHelperOptions
-    {
-        public bool SeparateFiles { get; set; }
-        public NumerazioneType NumerationType { get; set; }
-        public int CounterSize { get; set; }
-        public string Suffix { get; set; }
-        public int FilesPerFolder { get; set; }
-    }
-    public enum NumerazioneType
-    {
-        Progressiva,
-        Files
-    }
-    public class FileHelperSharp
-    {
-
-        public List<FileData> GetFilesRecursive(DirectoryInfo root, DirectoryInfo destRoot, string filter, FileHelperOptions options)
-        {
-            ConcurrentDictionary<FileInfo, DirectoryInfo> dirSourceDest = new ConcurrentDictionary<FileInfo, DirectoryInfo>();
-            List<FileInfo> result = new List<FileInfo>();
-
-            // Dim stack As New Stack(Of DirectoryInfo)
-            Stack<KeyValuePair<DirectoryInfo, DirectoryInfo>> stack = new Stack<KeyValuePair<DirectoryInfo, DirectoryInfo>>();
-
-
-
-            KeyValuePair<DirectoryInfo, DirectoryInfo> pair = new KeyValuePair<DirectoryInfo, DirectoryInfo>();
-
-
-            // stack.Push(root)
-            stack.Push(new KeyValuePair<DirectoryInfo, DirectoryInfo>(root, destRoot));
-
-            while ((stack.Count > 0))
-            {
-                KeyValuePair<DirectoryInfo, DirectoryInfo> curDirKV = stack.Pop();
-                // curDirKP = stack.Pop()
-                DirectoryInfo dir = curDirKV.Key;
-                DirectoryInfo dDir = curDirKV.Value;
-                try
-                {
-                    // result.AddRange(dir.GetFiles(filter, SearchOption.TopDirectoryOnly))
-                    // dividere file qui
-                    if (options.FilesPerFolder > 0 & options.SeparateFiles)
-                        AppendDictionaryConcurrent(dirSourceDest, DividiFilesInDirConcurrent(dir, dDir, options, filter));
-                    else
-                        AppendDictionaryConcurrent(dirSourceDest, DividiFilesInDirConcurrent(dir, dDir, options, filter));
-
-                    foreach (DirectoryInfo subDirectory in dir.GetDirectories())
-                        stack.Push(new KeyValuePair<DirectoryInfo, DirectoryInfo>(subDirectory, new DirectoryInfo(Path.Combine(dDir.FullName, subDirectory.Name))));
-                }
-                catch (Exception ex)
-                {
-                    // TODO ERROR
-                }
-            }
-
-            List<FileData> resultData = new List<FileData>();
-            resultData.AddRange(from p in dirSourceDest
-                                select new FileData(p.Key, p.Value));
-            return resultData;
-        }
-
-        public ConcurrentDictionary<FileInfo, DirectoryInfo> AppendDictionaryConcurrent(ConcurrentDictionary<FileInfo, DirectoryInfo> dictA, ConcurrentDictionary<FileInfo, DirectoryInfo> dictB)
-        {
-            foreach (KeyValuePair<FileInfo, DirectoryInfo> pair in dictB)
-                dictA.TryAdd(pair.Key, pair.Value);
-            return dictA;
-        }
-
-
-        private ConcurrentDictionary<FileInfo, DirectoryInfo> DividiFilesInDirConcurrent(DirectoryInfo dir, DirectoryInfo dirDest, FileHelperOptions options, string filter)
-        {
-            //int filesCount = dir.GetFiles(Filter).Length;
-            int contaFilePerDir = 0;
-            int contaDirPerDir = 0;
-            string tempText;// = string.Empty;
-            ConcurrentDictionary<FileInfo, DirectoryInfo> foldersDict = new ConcurrentDictionary<FileInfo, DirectoryInfo>();
-
-            DirectoryInfo destDir;
-            destDir = new DirectoryInfo(Path.Combine(dirDest.FullName));
-            foreach (FileInfo file in dir.GetFiles(filter))
-            {
-                contaFilePerDir += 1;
-
-                if (contaFilePerDir == (contaDirPerDir * options.FilesPerFolder) + 1)
-                {
-                    contaDirPerDir += 1;
-
-                    tempText = options.NumerationType == NumerazioneType.Progressiva ? contaDirPerDir.ToString() : (contaDirPerDir * options.FilesPerFolder).ToString();
-                    int i;
-                    for (i = 1; i <= (options.CounterSize - tempText.Length); i++)
-                        tempText = "0" + tempText;
-                    destDir = new DirectoryInfo(Path.Combine(dirDest.FullName, options.Suffix + tempText));
-                }
-
-                if (!destDir.Exists)
-                    destDir.Create();
-
-                foldersDict.TryAdd(file, destDir);
-            }
-
-            return foldersDict;
-        }
-
-    }
-}

MaddoShared.backup/ImageCreationStuff.cs

@@ -1,194 +0,0 @@
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using CatalogVbLib;
-using Dasync.Collections;
-
-namespace MaddoShared
-{
-    public class ImageCreationStuff
-    {
-        public class Options
-        {
-            public bool AggiornaSottodirectory { get; set; }
-            public bool CreaSottocartelle { get; set; }
-
-            public int FilePerCartella { get; set; }
-            public string SuffissoCartelle { get; set; }
-            public int CifreContatore { get; set; }
-            public NumerazioneType NumerazioneType { get; set; }
-            public string SourcePath { get; set; }
-            public string DestinationPath { get; set; }
-
-            public int MaxThreads { get; set; }
-            public int ChunksSize { get; set; }
-            public bool LinearExecution { get; set; }
-        }
-
-        public async Task<string> CreaCatalogoParallel(Options options, ConcurrentBag<string> results, EventHandler<Tuple<string,int>> updateEvent, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            var stopwatch = new Stopwatch();
-            stopwatch.Start();
-            // todo immagini counter
-            //todo set label
-            await CreaImmaginiParallel(options, results, updateEvent, cancellationToken);
-
-            // todo set finito label
-            stopwatch.Stop();
-
-            return $"{stopwatch.Elapsed.Hours}h {stopwatch.Elapsed.Minutes}m ${stopwatch.Elapsed.Seconds}s ({stopwatch.Elapsed.TotalSeconds}s)";
-
-
-        }
-
-        public async Task CreaImmaginiParallel(Options options, ConcurrentBag<string> results, EventHandler<Tuple<string, int>> updateEvent, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            var dataToProcess = new List<FileData>();
-            if (options.AggiornaSottodirectory && options.CreaSottocartelle)
-            {
-                var helper = new FileHelperSharp();
-                dataToProcess = helper.GetFilesRecursive(new DirectoryInfo(options.SourcePath), new DirectoryInfo(options.DestinationPath),
-                    "*.jpg", new FileHelperOptions()
-                    {
-                        FilesPerFolder = options.FilePerCartella,
-                        Suffix = options.SuffissoCartelle,
-                        CounterSize = options.CifreContatore,
-                        NumerationType = options.NumerazioneType
-                    });
-            }
-            else if (!options.CreaSottocartelle)
-            {
-                var files = Directory.EnumerateFiles(options.SourcePath, "*.jpg",
-                    options.AggiornaSottodirectory
-                        ? SearchOption.AllDirectories
-                        : SearchOption.TopDirectoryOnly);
-
-                dataToProcess = files.Select(x =>
-                {
-                    var fInfo = new FileInfo(x);
-                    var filePath = fInfo.DirectoryName;
-                    var trimmedSourcePath = options.SourcePath.TrimEnd('\\');
-                    var newFilePath = fInfo.FullName.Replace(trimmedSourcePath, "").TrimStart('\\');
-                    newFilePath = Path.Combine(options.DestinationPath, newFilePath);
-
-                    var destFolderPath = new FileInfo(newFilePath).DirectoryName;
-                    var destFolderInfo = new DirectoryInfo(destFolderPath);
-                    destFolderInfo.EnsureDirectoryExists();
-
-                    return new FileData(fInfo, new DirectoryInfo(new FileInfo(newFilePath).DirectoryName));
-                }).ToList();
-
-                //// TODO
-                //dataToProcess =
-                //    (from f in Directory.EnumerateFiles(options.SourcePath, "*.jpg",
-                //            options.AggiornaSottodirectory
-                //                ? SearchOption.AllDirectories
-                //                : SearchOption.TopDirectoryOnly)
-                //     select new FileData(new FileInfo(f),
-                //         new DirectoryInfo(options.DestinationPath.PathCombine(
-                //             new FileInfo(f).DirectoryName.Replace(options.SourcePath.TrimEnd(new char[] {'\\'}), "")
-                //             )
-                //         )
-                //         )
-                //        )
-                //    .ToList();
-            }
-
-            var threads = options.MaxThreads == 0 ? Environment.ProcessorCount * 2 : options.MaxThreads;
-            var scheduler = new ConcurrentExclusiveSchedulerPair(TaskScheduler.Default, threads)
-                .ConcurrentScheduler;
-
-            //var allTasks = new List<Task>();
-            var test = from d in dataToProcess
-                       select Task.Factory.StartNew(async () =>
-                       {
-                           await new ImageCreatorSharp(d.File, d.Directory).CreaImmagineThread(d.File.Name);
-
-                           //var imgC = new ImageCreatorSharp(d.File, d.Directory);
-                           //imgC.CreaImmagineThread(d.File.Name);
-                           //imgC = null;
-                       }, CancellationToken.None, TaskCreationOptions.None, scheduler);
-
-            //int count = 0;
-
-            if (options.LinearExecution)
-            {
-                foreach (var task in test)
-                {
-                    await task;
-                }
-            }
-            else
-            {
-                if (options.ChunksSize == 0)
-                {
-
-
-                    //var opts = new ParallelOptions() { MaxDegreeOfParallelism = threads, CancellationToken = cancellationToken, TaskScheduler = scheduler};
-                    await dataToProcess.ParallelForEachAsync(async fileData =>
-                   {
-                       await new ImageCreatorSharp(fileData.File, fileData.Directory).CreaImmagineThread(fileData.File.Name);
-                       results.Add(fileData.File.Name);
-                       //count = Interlocked.Increment(ref count);
-                       try
-                       {
-                           updateEvent?.Invoke(this, new Tuple<string, int>(fileData.File.Name, dataToProcess.Count) );
-                       }
-                       catch (Exception e)
-                       {
-                           Console.WriteLine(e);
-                           throw;
-                       }
-
-                   }, maxDegreeOfParallelism: threads, false, cancellationToken);
-
-
-                }
-                else
-                {
-
-                    var asdf = SplitList(dataToProcess.ToList(), options.ChunksSize).ToList();
-                   
-
-                    foreach (var sdaf in asdf)
-                    {
-                        await sdaf.ParallelForEachAsync(async fileData =>
-                        {
-                            await new ImageCreatorSharp(fileData.File, fileData.Directory).CreaImmagineThread(fileData.File.Name);
-                            results.Add(fileData.File.Name);
-                            //count = Interlocked.Increment(ref count);
-                            try
-                            {
-                                updateEvent?.Invoke(this, new Tuple<string, int>(fileData.File.Name, dataToProcess.Count));
-                            }
-                            catch (Exception e)
-                            {
-                                Console.WriteLine(e);
-                                throw;
-                            }
-                        }, maxDegreeOfParallelism: threads, false, cancellationToken);
-                    }
-
-
-
-                }
-            }
-
-
-        }
-
-        public static IEnumerable<List<T>> SplitList<T>(List<T> bigList, int nSize = 3)
-        {
-            for (int i = 0; i < bigList.Count; i += nSize)
-            {
-                yield return bigList.GetRange(i, Math.Min(nSize, bigList.Count - i));
-            }
-        }
-    }
-}

MaddoShared.backup/MaddoShared.csproj

@@ -1,101 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectGuid>{AEBFE9E3-277C-4A7B-8448-145D1B11998B}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>MaddoShared</RootNamespace>
-    <AssemblyName>MaddoShared</AssemblyName>
-    <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <Deterministic>true</Deterministic>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="AsyncEnumerable, Version=4.0.2.0, Culture=neutral, PublicKeyToken=0426b068161bd1d1, processorArchitecture=MSIL">
-      <HintPath>..\packages\AsyncEnumerator.4.0.2\lib\net461\AsyncEnumerable.dll</HintPath>
-    </Reference>
-    <Reference Include="Ben.Demystifier, Version=0.3.0.0, Culture=neutral, PublicKeyToken=a6d206e05440431a, processorArchitecture=MSIL">
-      <HintPath>..\packages\Ben.Demystifier.0.3.0\lib\net45\Ben.Demystifier.dll</HintPath>
-    </Reference>
-    <Reference Include="Microsoft.Bcl.AsyncInterfaces, Version=5.0.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
-      <HintPath>..\packages\Microsoft.Bcl.AsyncInterfaces.5.0.0\lib\net461\Microsoft.Bcl.AsyncInterfaces.dll</HintPath>
-    </Reference>
-    <Reference Include="SixLabors.ImageSharp, Version=1.0.0.0, Culture=neutral, PublicKeyToken=d998eea7b14cab13, processorArchitecture=MSIL">
-      <HintPath>..\packages\SixLabors.ImageSharp.1.0.3\lib\net472\SixLabors.ImageSharp.dll</HintPath>
-    </Reference>
-    <Reference Include="System" />
-    <Reference Include="System.Buffers, Version=4.0.3.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.Buffers.4.5.1\lib\net461\System.Buffers.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Collections.Immutable, Version=5.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.Collections.Immutable.5.0.0\lib\net461\System.Collections.Immutable.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Core" />
-    <Reference Include="System.Drawing" />
-    <Reference Include="System.Memory, Version=4.0.1.1, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.Memory.4.5.4\lib\net461\System.Memory.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Numerics" />
-    <Reference Include="System.Numerics.Vectors, Version=4.1.4.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.Numerics.Vectors.4.5.0\lib\net46\System.Numerics.Vectors.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Reflection.Metadata, Version=5.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.Reflection.Metadata.5.0.0\lib\net461\System.Reflection.Metadata.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Runtime.CompilerServices.Unsafe, Version=5.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.Runtime.CompilerServices.Unsafe.5.0.0\lib\net45\System.Runtime.CompilerServices.Unsafe.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Threading.Tasks.Extensions, Version=4.2.0.1, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.Threading.Tasks.Extensions.4.5.4\lib\net461\System.Threading.Tasks.Extensions.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Windows.Forms" />
-    <Reference Include="System.Xml.Linq" />
-    <Reference Include="System.Data.DataSetExtensions" />
-    <Reference Include="Microsoft.CSharp" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Net.Http" />
-    <Reference Include="System.Xml" />
-    <Reference Include="Z.ExtensionMethods, Version=2.1.1.0, Culture=neutral, PublicKeyToken=59b66d028979105b, processorArchitecture=MSIL">
-      <HintPath>..\packages\Z.ExtensionMethods.2.1.1\lib\net45\Z.ExtensionMethods.dll</HintPath>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="ImageCreationStuff.cs" />
-    <Compile Include="ImageCreatorSharp.cs" />
-    <Compile Include="ThreadingHelper.cs" />
-    <Compile Include="FileData.cs" />
-    <Compile Include="FileHelperSharp.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\CatalogVbLib\CatalogVbLib.vbproj">
-      <Project>{44465926-240d-473f-90b8-786ba4384406}</Project>
-      <Name>CatalogVbLib</Name>
-    </ProjectReference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="app.config" />
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-</Project>

MaddoShared.backup/Properties/AssemblyInfo.cs

@@ -1,36 +0,0 @@
-using System.Reflection;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-// General Information about an assembly is controlled through the following
-// set of attributes. Change these attribute values to modify the information
-// associated with an assembly.
-[assembly: AssemblyTitle("MaddoShared")]
-[assembly: AssemblyDescription("")]
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("MaddoShared")]
-[assembly: AssemblyCopyright("Copyright ©  2021")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-
-// Setting ComVisible to false makes the types in this assembly not visible
-// to COM components.  If you need to access a type in this assembly from
-// COM, set the ComVisible attribute to true on that type.
-[assembly: ComVisible(false)]
-
-// The following GUID is for the ID of the typelib if this project is exposed to COM
-[assembly: Guid("aebfe9e3-277c-4a7b-8448-145d1b11998b")]
-
-// Version information for an assembly consists of the following four values:
-//
-//      Major Version
-//      Minor Version
-//      Build Number
-//      Revision
-//
-// You can specify all the values or you can default the Build and Revision Numbers
-// by using the '*' as shown below:
-// [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]

MaddoShared.backup/ThreadingHelper.cs

@@ -1,60 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace MaddoShared
-{
-    public static class ThreadingHelper
-    {
-        /// <summary>
-        /// Starts the given tasks and waits for them to complete. This will run, at most, the specified number of tasks in parallel.
-        /// <para>NOTE: If one of the given tasks has already been started, an exception will be thrown.</para>
-        /// </summary>
-        /// <param name="tasksToRun">The tasks to run.</param>
-        /// <param name="maxTasksToRunInParallel">The maximum number of tasks to run in parallel.</param>
-        /// <param name="cancellationToken">The cancellation token.</param>
-        public static void StartAndWaitAllThrottled(IEnumerable<Task> tasksToRun, int maxTasksToRunInParallel, CancellationToken cancellationToken = new CancellationToken())
-        {
-            StartAndWaitAllThrottled(tasksToRun, maxTasksToRunInParallel, -1, cancellationToken);
-        }
-
-        /// <summary>
-        /// Starts the given tasks and waits for them to complete. This will run, at most, the specified number of tasks in parallel.
-        /// <para>NOTE: If one of the given tasks has already been started, an exception will be thrown.</para>
-        /// </summary>
-        /// <param name="tasksToRun">The tasks to run.</param>
-        /// <param name="maxTasksToRunInParallel">The maximum number of tasks to run in parallel.</param>
-        /// <param name="timeoutInMilliseconds">The maximum milliseconds we should allow the max tasks to run in parallel before allowing another task to start. Specify -1 to wait indefinitely.</param>
-        /// <param name="cancellationToken">The cancellation token.</param>
-        public static void StartAndWaitAllThrottled(IEnumerable<Task> tasksToRun, int maxTasksToRunInParallel, int timeoutInMilliseconds, CancellationToken cancellationToken = new CancellationToken())
-        {
-            // Convert to a list of tasks so that we don&#39;t enumerate over it multiple times needlessly.
-            var tasks = tasksToRun.ToList();
-
-            using (var throttler = new SemaphoreSlim(maxTasksToRunInParallel))
-            {
-                var postTaskTasks = new List<Task>();
-
-                // Have each task notify the throttler when it completes so that it decrements the number of tasks currently running.
-                tasks.ForEach(t => postTaskTasks.Add(t.ContinueWith(tsk => throttler.Release())));
-
-                // Start running each task.
-                foreach (var task in tasks)
-                {
-                    // Increment the number of tasks currently running and wait if too many are running.
-                    throttler.Wait(timeoutInMilliseconds, cancellationToken);
-
-                    cancellationToken.ThrowIfCancellationRequested();
-                    task.Start();
-                }
-
-                // Wait for all of the provided tasks to complete.
-                // We wait on the list of "post" tasks instead of the original tasks, otherwise there is a potential race condition where the throttler&#39;s using block is exited before some Tasks have had their "post" action completed, which references the throttler, resulting in an exception due to accessing a disposed object.
-                Task.WaitAll(postTaskTasks.ToArray(), cancellationToken);
-            }
-        }
-    }
-}

MaddoShared.backup/app.config

@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<configuration>
-  <runtime>
-    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
-      <dependentAssembly>
-        <assemblyIdentity name="System.Threading.Tasks.Extensions" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
-        <bindingRedirect oldVersion="0.0.0.0-4.2.0.1" newVersion="4.2.0.1" />
-      </dependentAssembly>
-      <dependentAssembly>
-        <assemblyIdentity name="Microsoft.Bcl.AsyncInterfaces" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
-        <bindingRedirect oldVersion="0.0.0.0-5.0.0.0" newVersion="5.0.0.0" />
-      </dependentAssembly>
-      <dependentAssembly>
-        <assemblyIdentity name="System.Runtime.CompilerServices.Unsafe" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
-        <bindingRedirect oldVersion="0.0.0.0-5.0.0.0" newVersion="5.0.0.0" />
-      </dependentAssembly>
-    </assemblyBinding>
-  </runtime>
-</configuration>

MaddoShared.backup/packages.config

@@ -1,15 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="AsyncEnumerator" version="4.0.2" targetFramework="net472" />
-  <package id="Ben.Demystifier" version="0.3.0" targetFramework="net472" />
-  <package id="Microsoft.Bcl.AsyncInterfaces" version="5.0.0" targetFramework="net472" />
-  <package id="SixLabors.ImageSharp" version="1.0.3" targetFramework="net472" />
-  <package id="System.Buffers" version="4.5.1" targetFramework="net472" />
-  <package id="System.Collections.Immutable" version="5.0.0" targetFramework="net472" />
-  <package id="System.Memory" version="4.5.4" targetFramework="net472" />
-  <package id="System.Numerics.Vectors" version="4.5.0" targetFramework="net472" />
-  <package id="System.Reflection.Metadata" version="5.0.0" targetFramework="net472" />
-  <package id="System.Runtime.CompilerServices.Unsafe" version="5.0.0" targetFramework="net472" />
-  <package id="System.Threading.Tasks.Extensions" version="4.5.4" targetFramework="net472" />
-  <package id="Z.ExtensionMethods" version="2.1.1" targetFramework="net472" />
-</packages>

MaddoShared.backup/upgrade.backup

@@ -1 +0,0 @@
-Backup created at 1615021651 (06/03/2021 09:07:31 +00:00)

MaddoShared/IImageCreator.cs

@@ -1,9 +1,8 @@
-using System.Drawing;
 using System.Threading.Tasks;
 
 namespace MaddoShared;
 
 public interface IImageCreator
 {
-    Task CreateImageAsync(ImageState imgState, Image logo);
+    Task CreateImageAsync(ImageState imgState, byte[]? logoData);
 }

MaddoShared/ImageCreationStuff.cs

@@ -3,7 +3,6 @@ using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
-using System.Drawing;
 using System.IO;
 using System.Linq;
 using System.Text;
@@ -14,7 +13,6 @@ using Microsoft.Extensions.Logging;
 
 namespace MaddoShared
 {
-    [SuppressMessage("Interoperability", "CA1416:Validate platform compatibility")]
     public class ImageCreationService(
         ILogger<ImageCreationService> logger,
         PicSettings picSettings,
@@ -72,19 +70,15 @@ namespace MaddoShared
             // int threads = options.MaxThreads == 0 ? Environment.ProcessorCount * 2 : options.MaxThreads;
             int threads = options.MaxThreads;
 
-            Bitmap logoBmp = null;
-            // Load Logo (short-circuit)
+            // Load logo once as raw bytes (cross-platform). byte[] is safe to share across threads.
+            byte[]? logoBytes = null;
             if (picSettings.LogoAggiungi && File.Exists(picSettings.LogoNomeFile))
             {
-                logoBmp = new Bitmap(picSettings.LogoNomeFile);
+                logoBytes = File.ReadAllBytes(picSettings.LogoNomeFile);
             }
 
             Func<FileData, Task> processFile = async fileData =>
             {
-                Bitmap logoCopy = logoBmp is null
-                    ? null
-                    : logoBmp.Clone(new Rectangle(0, 0, logoBmp.Width, logoBmp.Height), logoBmp.PixelFormat);
-
                 var imgState = new ImageState
                 {
                     WorkFile = fileData.File,
@@ -93,8 +87,7 @@ namespace MaddoShared
 
                 try
                 {
-                    // Ensure CreateImageAsync can accept a null logoCopy value.
-                    await imageCreatorService.CreateImageAsync(imgState, logoCopy);
+                    await imageCreatorService.CreateImageAsync(imgState, logoBytes);
 
                     results.Add(fileData.File.Name);
 
@@ -110,8 +103,7 @@ namespace MaddoShared
                 }
                 finally
                 {
-                    // Dispose the clone if it was created
-                    logoCopy?.Dispose();
+                    // nothing to dispose — byte[] is managed
                 }
             };
 
@@ -139,14 +131,6 @@ namespace MaddoShared
                 }
             }
 
-            try
-            {
-                logoBmp?.Dispose();
-            }
-            catch (Exception e)
-            {
-                logger.LogError(e, "Error in disposing the logo");
-            }
         }
 
         private List<FileData> GetFilesToProcess(Options options)