WPF

I am trying to print labels with a height of 38mm. The number in a run can be from 1 to 2000. The preview like in a document viewer would be desirable. The label height is entered in the printer's print settings. The printer is not the default printer in the user profile. In the DocumentViewer, however, the print settings are only loaded if it is the default printer.
I want to specify the printer from a CONFIG file and the label height must be 38mm, not DIN A4!
I can't get any further without a program example. Thank you for help. 

Hey all I have the following OnStartup for my WPF desktop app that goes to a local directory and gathers all the images within that folder (box1 being the example code below):

<pre lang="C#">public partial class App : Application
    {
        protected override void OnStartup(StartupEventArgs e)
        {
            base.OnStartup(e);

            // set the update interval
            var imageSource = new ImageSource(Path.Combine(@"C:\photos\boxes\", "box1"), TimeSpan.FromHours(1));
            var viewModel = new MainWindowViewModel(imageSource);

            var window = new MainWindow()
            {
                DataContext = viewModel
            };

            window.Closed += (s, a) => { viewModel.Dispose(); };
            window.Show();
        }
    }

C:\
 |-photos\
    |boxes\
      |box1
      |box2
      |box3
      |box4
      |box5
      |box6
      |box7
      |box8
      |box9
      |box10

<Window.Resources>
        <!-- List of supported animations -->
        <FluidKit:SlideTransition x:Key="SlideTransition" x:Shared="False"/>
        <FluidKit:CubeTransition x:Key="CubeTransition" Rotation="BottomToTop" x:Shared="False"/>
        <FluidKit:FlipTransition x:Key="FlipTransition" x:Shared="False"/>
        <local:ImageSourceConverter x:Key="ImageSourceConverter"/>
        <!-- Data template for animations -->
        <DataTemplate x:Key="ItemTemplate" x:Shared="False">
            <Image Source="{Binding Path, Converter={StaticResource ImageSourceConverter}}"
                   Stretch="Fill"/>
        </DataTemplate>
    </Window.Resources>
    <Grid>
        <FluidKit:TransitionPresenter RestDuration="0:0:3"
                                          IsLooped="True"
                                        Transition="{StaticResource FlipTransition}"
                                       ItemsSource="{Binding box1}"
                                             Width="357"
                                            Height="272"
                               HorizontalAlignment="Left"
                                 VerticalAlignment="Top"
                                      ItemTemplate="{StaticResource ItemTemplate}"
                                            x:Name="box1"
                                            Margin="0,0,0,454"/>
        <FluidKit:TransitionPresenter RestDuration="0:0:3"
                                          IsLooped="True"
                                        Transition="{StaticResource FlipTransition}"
                                       ItemsSource="{Binding box2}"
                                             Width="357"
                                            Height="272"
                               HorizontalAlignment="Left"
                                 VerticalAlignment="Top"
                                      ItemTemplate="{StaticResource ItemTemplate}"
                                            x:Name="box2"
                                            Margin="357,0,0,0"/>
       ETC.......

public class MainWindowViewModel : IDisposable
{
    private readonly IDisposable _token1;
    private readonly IDisposable _token2;
    ...ETC

    public MainWindowViewModel(IImageSource imageSource)
    {
        // subscribe to update images at regular intervals
        _token1 = imageSource
            .GetImages().ObserveOn(DispatcherScheduler.Current)
            .Subscribe(i => UpdateImages(i, box1), ex => ShowError(ex));

        _token2 = imageSource
            .GetImages().ObserveOn(DispatcherScheduler.Current)
            .Subscribe(i => UpdateImages(i, box2), ex => ShowError(ex));
        ETC...
    }

    private void ShowError(Exception ex)
    {
        MessageBox.Show(ex.Message, "Photo Gallery", MessageBoxButton.OK, MessageBoxImage.Error);
    }

    /// <summary>
    /// Updates the animation's images.
    /// </summary>
    /// <param name="images">The images to update with</param>
    /// <param name="animation">The animation to update</param>
    private void UpdateImages(IEnumerable<string> images, ObservableCollection<ImageViewModel> animation)
    {
        animation.Clear();

        foreach (var i in images)
        {
            animation.Add(new ImageViewModel { Path = i });
        }
    }

    /// <summary>
    /// Gets or sets a collection of images used for the first animation.
    /// </summary>
    public ObservableCollection<ImageViewModel> box1 { get; set; } =
        new ObservableCollection<ImageViewModel>();

    public ObservableCollection<ImageViewModel> box2 { get; set; } =
        new ObservableCollection<ImageViewModel>();

    ETC...

    public void Dispose()
    {
        _token1.Dispose();
        _token2.Dispose();
        ETC...
    }
}

public class ImageSource : IImageSource
{
    private readonly string _path;
    private readonly TimeSpan _interval;

    public ImageSource(string path, TimeSpan interval)
    {
        _path = path;
        _interval = interval;
    }

    public IObservable<IEnumerable<string>> GetImages()
    {
        if (!Directory.Exists(_path))
        {
            return Observable.Empty<IEnumerable<string>>();
        }

        return Observable.Create<IEnumerable<string>>(observer =>
        {
            return TaskPoolScheduler.Default.ScheduleAsync(async (ctrl, ct) =>
            {
                for (;;)
                {
                    if (ct.IsCancellationRequested)
                    {
                        break;
                    }

                    try
                    {
                        var images = Directory.GetFiles(_path, "*.jpg");

                        // Don’t do anything unless there are a minimum of 10 images.
                        if (images.Count() > 9)
                        {
                            observer.OnNext(images.PickRandom());
                        }
                    }
                    catch (Exception ex)
                    {
                        observer.OnError(ex);
                        throw;
                    }

                    await ctrl.Sleep(_interval).ConfigureAwait(false);
                 }
            });
        });
    }

<Image Source="{Binding Path,
                Converter={StaticResource ImageSourceConverter}}"
                Stretch="Fill"
/>

<Window.Resources>
     <!-- List of supported animations -->
     <FluidKit:SlideTransition x:Key="SlideTransition" x:Shared="False"/>
     <FluidKit:CubeTransition x:Key="CubeTransition" Rotation="BottomToTop" x:Shared="False"/>
     <FluidKit:FlipTransition x:Key="FlipTransition" x:Shared="False"/>
     <local1:ImageSourceConverter x:Key="ImageSourceConverter"/>
     <!-- Data template for animations -->
     <DataTemplate x:Key="ItemTemplate" x:Shared="False">
         <Image Source="{Binding Path,
             Converter={StaticResource ImageSourceConverter}}"
                Stretch="Fill"/>
     </DataTemplate>
 </Window.Resources>
 <Grid x:Name="imageAreas" HorizontalAlignment="Left" Height="1920" Margin="0,0,0,0" VerticalAlignment="Top" Width="1080" ScrollViewer.VerticalScrollBarVisibility="Disabled">
         <Grid HorizontalAlignment="Left" Height="726" VerticalAlignment="Top" Width="1080" x:Name="topGrid">
             <FluidKit:TransitionPresenter RestDuration="0:0:3"
                                       IsLooped="True"
                                     Transition="{StaticResource FlipTransition}"
                                    ItemsSource="{Binding Images1}"
                                          Width="357"
                                         Height="272"
                            HorizontalAlignment="Left"
                              VerticalAlignment="Top"
                                   ItemTemplate="{StaticResource ItemTemplate}"
                                         x:Name="box1"
                                         Margin="0,0,0,454"/>
             <FluidKit:TransitionPresenter RestDuration="0:0:3"
                                       IsLooped="True"
                                     Transition="{StaticResource FlipTransition}"
                                    ItemsSource="{Binding Images2}"
                                          Width="357"
                                         Height="272"
                            HorizontalAlignment="Left"
                              VerticalAlignment="Top"
                                   ItemTemplate="{StaticResource ItemTemplate}"
                                         x:Name="box2"
                                         Margin="357,0,0,0"/>
   ....ETC....

/// <summary>
/// This converter automatically disposes image streams as soon as images
/// are loaded, thus avoiding file access exceptions when attempting to delete images.
/// </summary>
public sealed class ImageSourceConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        string path = value as string;
        if (path != null)
        {
            //create new stream and create bitmap frame
            var bitmapImage = new BitmapImage();
            bitmapImage.BeginInit();
            bitmapImage.StreamSource = new FileStream(path, FileMode.Open, FileAccess.Read);
            //load the image now so we can immediately dispose of the stream
            bitmapImage.CacheOption = BitmapCacheOption.OnLoad;
            bitmapImage.EndInit();

            //clean up the stream to avoid file access exceptions when attempting to delete images
            bitmapImage.StreamSource.Dispose();

            return bitmapImage;
        }
        else
        {
            return DependencyProperty.UnsetValue;
        }
    }

    public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        return DependencyProperty.UnsetValue;
    }
}

public class MainWindowViewModel : IDisposable
{
    private readonly IDisposable _token1;
    private readonly IDisposable _token2;
    private readonly IDisposable _token3;
    private readonly IDisposable _token4;
    private readonly IDisposable _token5;
    private readonly IDisposable _token6;
    private readonly IDisposable _token7;
    private readonly IDisposable _token8;
    private readonly IDisposable _token9;
    private readonly IDisposable _token10;

    public MainWindowViewModel(IImageSource imageSource)
    {
        // subscribe to update images at regular intervals
        _token1 = imageSource
            .GetImages(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "box1"))
            .ObserveOn(DispatcherScheduler.Current)
            .Subscribe(i => UpdateImages(i, box1), ex => ShowError(ex));

        _token2 = imageSource
            .GetImages(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "box2"))
            .ObserveOn(DispatcherScheduler.Current)
            .Subscribe(i => UpdateImages(i, box2), ex => ShowError(ex));

        _token3 = imageSource
            .GetImages(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "box3"))
            .ObserveOn(DispatcherScheduler.Current)
            .Subscribe(i => UpdateImages(i, box3), ex => ShowError(ex));

        _token4 = imageSource
            .GetImages(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "box4"))
            .ObserveOn(DispatcherScheduler.Current)
            .Subscribe(i => UpdateImages(i, box4), ex => ShowError(ex));

        _token5 = imageSource
            .GetImages(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "box5"))
            .ObserveOn(DispatcherScheduler.Current)
            .Subscribe(i => UpdateImages(i, box5), ex => ShowError(ex));

        _token6 = imageSource
            .GetImages(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "box6"))
            .ObserveOn(DispatcherScheduler.Current)
            .Subscribe(i => UpdateImages(i, box6), ex => ShowError(ex));

        _token7 = imageSource
            .GetImages(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "box7"))
            .ObserveOn(DispatcherScheduler.Current)
            .Subscribe(i => UpdateImages(i, box7), ex => ShowError(ex));

        _token8 = imageSource
            .GetImages(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "box8"))
            .ObserveOn(DispatcherScheduler.Current)
            .Subscribe(i => UpdateImages(i, box8), ex => ShowError(ex));

        _token9 = imageSource
            .GetImages(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "box9"))
            .ObserveOn(DispatcherScheduler.Current)
            .Subscribe(i => UpdateImages(i, box9), ex => ShowError(ex));

        _token10 = imageSource
            .GetImages(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "box10"))
            .ObserveOn(DispatcherScheduler.Current)
            .Subscribe(i => UpdateImages(i, box10), ex => ShowError(ex));
    }

    private void ShowError(Exception ex)
    {
        MessageBox.Show(ex.Message,
                        "Photo Gallery", MessageBoxButton.OK, MessageBoxImage.Error);
    }

    /// <summary>
    /// Updates the animation's images.
    /// </summary>
    /// <param name="images">The images to update with</param>
    /// <param name="animation">The animation to update</param>
    private void UpdateImages(IEnumerable<string> images, ObservableCollection<ImageViewModel> animation)
    {
        animation.Clear();
        foreach (var i in images)
        {
            animation.Add(new ImageViewModel { Path = i });
        }
    }

    /// <summary>
    /// Gets or sets a collection of images used for the first animation.
    /// </summary>
    public ObservableCollection<ImageViewModel> box1 { get; set; } =
        new ObservableCollection<ImageViewModel>();

    /// <summary>
    /// Gets or sets a collection of images used for the second animation.
    /// </summary>
    public ObservableCollection<ImageViewModel> box2 { get; set; } =
        new ObservableCollection<ImageViewModel>();

    /// <summary>
    /// Gets or sets a collection of images used for the third animation.
    /// </summary>
    public ObservableCollection<ImageViewModel> box3 { get; set; } =
        new ObservableCollection<ImageViewModel>();

    /// <summary>
    /// Gets or sets a collection of images used for the fourth animation.
    /// </summary>
    public ObservableCollection<ImageViewModel> box4 { get; set; } =
        new ObservableCollection<ImageViewModel>();

    /// <summary>
    /// Gets or sets a collection of images used for the fifth animation.
    /// </summary>
    public ObservableCollection<ImageViewModel> box5 { get; set; } =
        new ObservableCollection<ImageViewModel>();

    /// <summary>
    /// Gets or sets a collection of images used for the sixth animation.
    /// </summary>
    public ObservableCollection<ImageViewModel> box6 { get; set; } =
        new ObservableCollection<ImageViewModel>();

    /// <summary>
    /// Gets or sets a collection of images used for the seventh animation.
    /// </summary>
    public ObservableCollection<ImageViewModel> box7 { get; set; } =
        new ObservableCollection<ImageViewModel>();

    /// <summary>
    /// Gets or sets a collection of images used for the eighth animation.
    /// </summary>
    public ObservableCollection<ImageViewModel> box8 { get; set; } =
        new ObservableCollection<ImageViewModel>();

    /// <summary>
    /// Gets or sets a collection of images used for the nineth animation.
    /// </summary>
    public ObservableCollection<ImageViewModel> box9 { get; set; } =
        new ObservableCollection<ImageViewModel>();

    /// <summary>
    /// Gets or sets a collection of images used for the tenth animation.
    /// </summary>
    public ObservableCollection<ImageViewModel> box10 { get; set; } =
        new ObservableCollection<ImageViewModel>();

    public void Dispose()
    {
        _token1.Dispose();
        _token2.Dispose();
        _token3.Dispose();
        _token4.Dispose();
        _token5.Dispose();
        _token6.Dispose();
        _token7.Dispose();
        _token8.Dispose();
        _token9.Dispose();
        _token10.Dispose();
    }
}

public interface IImageSource
{
    IObservable<IEnumerable<string>> GetImages(string path);
}

public class ImageSource : IImageSource
{
    TimeSpan _pollingInterval;

    public ImageSource(TimeSpan pollingInterval)
    {
        _pollingInterval = pollingInterval;
    }

    public IObservable<IEnumerable<string>> GetImages(string path)
    {
        if (!Directory.Exists(path))
        {
            return Observable.Empty<IEnumerable<string>>();
        }

        try
        {
            return Observable.Create<IEnumerable<string>>(observer =>
            {
                return TaskPoolScheduler.Default.ScheduleAsync(async (ctrl, ct) =>
                {
                    for (; ; )
                    {
                        if (ct.IsCancellationRequested)
                        {
                            break;
                        }

                        try
                        {
                            var images = Directory.GetFiles(path, "*.jpg");
                            observer.OnNext(images);
                        }
                        catch (Exception ex)
                        {
                            observer.OnError(ex);
                            throw;
                        }

                        await ctrl.Sleep(_pollingInterval).ConfigureAwait(false);
                    }
                });
            });
        } catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
            return null;
        }
    }
}

public string MessageColor
  {
      get
      {
          if ( someBooleanValue )
              return "green";
          else
              return "red";
      }
  }

public string Message
  {
      get
      {
          if ( someBooleanValue )
              return "Success Message";
          else
              return "Failure Message";
      }
  }

public static ImageSource? BitmapFromRaw(byte[]? imageData)
{
    if (imageData == null) return null;
    var image = new BitmapImage();
    var mem = new MemoryStream(imageData);
    //mem.Position = 0;
    image.BeginInit();
    //image.CreateOptions = BitmapCreateOptions.PreservePixelFormat;
    //image.CacheOption = BitmapCacheOption.None;
    //image.UriSource = null;
    image.StreamSource = mem;
    image.EndInit();
    //mem.Close();
    //mem.Dispose();
    image.Freeze();

    return image;
}

<Window x:Class="Toy.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:Toy"
        mc:Ignorable="d"
        Title="MainWindow" Height="450" Width="800">
    <Grid>
        <StackPanel>
            <Button Content="Collect Garbage" Click="gcButton_Click"/>
            <Button x:Name="wxButton" Click="wxButton_Click"/>
            <ItemsControl x:Name="wxToy" ItemsSource="{Binding}" HorizontalAlignment="Center">
                <ItemsControl.ItemsPanel>
                    <ItemsPanelTemplate>
                        <WrapPanel/>
                    </ItemsPanelTemplate>
                </ItemsControl.ItemsPanel>
                <ItemsControl.ItemTemplate>
                    <DataTemplate>
                        <Border BorderBrush="Bisque" Width="100" Height="100" BorderThickness="2">
                            <Image Source="{Binding Data}"/>
                        </Border>
                    </DataTemplate>
                </ItemsControl.ItemTemplate>
            </ItemsControl>
        </StackPanel>
    </Grid>
</Window>

using System;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.IO;
using System.Runtime.CompilerServices;
using System.Windows;
using System.Windows.Media;
using System.Windows.Media.Imaging;

namespace Toy
{


	internal class ToyItem : INotifyPropertyChanged
    {
        #region Boilerplate INotifyPropertyChanged

        protected void OnPropertyChanged(PropertyChangedEventArgs e)
        {
            PropertyChanged?.Invoke(this, e);
        }

        public void OnPropertyChanged([CallerMemberName] string propertyName = "")
        {
            OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
        }
        public event PropertyChangedEventHandler? PropertyChanged;

		#endregion

        /// <summary>
		/// Build an image from Picture bytes
		/// </summary>
		/// <param name="imageData">Picture as array of bytes</param>
		/// <returns>Pictures as BitmapImage</returns>
		public static ImageSource? BitmapFromRaw(byte[]? imageData)
		{
			if (imageData == null) return null;
			var image = new BitmapImage();
            var mem = new MemoryStream(imageData);
			//mem.Position = 0;
			image.BeginInit();
			//image.CreateOptions = BitmapCreateOptions.PreservePixelFormat;
			//image.CacheOption = BitmapCacheOption.None;
			//image.UriSource = null;
			image.StreamSource = mem;
			image.EndInit();
            //mem.Close();
            //mem.Dispose();
            image.Freeze();
 
            return image;
		}

		public ImageSource? Data
        {
            get { return _Data; }
            set
            {
                if (value != _Data)
                {
                    _Data = value;
                    OnPropertyChanged();
                }
            }
        }
        private ImageSource? _Data;
        
        public ToyItem ()
        {
            Data = BitmapFromRaw(Properties.Resources.pexels_jonathan_faria_8581946);
        }

        ~ToyItem()
        {
            //if (Data == null) return;
            //var image = (BitmapImage)Data;
            //image.StreamSource.Close();
            //image.StreamSource.Dispose();
        }

    }

    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {

        ObservableCollection<ToyItem> ToyList = new ObservableCollection<ToyItem>();

        int Counter = 0;

        public MainWindow()
        {
            InitializeComponent();

            wxToy.DataContext = ToyList;
            wxButton.Content = Counter;
        }

        private void gcButton_Click(object sender, RoutedEventArgs e)
        {
            GC.Collect();
        }

        private void wxButton_Click(object sender, RoutedEventArgs e)
        {
            wxButton.Content = ++Counter;

            ToyList.Clear();

            for (int i = 0; i < 5; i++)
            {
                ToyList.Add(new ToyItem());
            }
        }
    }

}

private void wxButton_Click(object sender, RoutedEventArgs e)
{

    // Memory leak Fix
    for (int i = 0; i < wxToy.Items.Count; i++)
    {
        var uiElement = (FrameworkElement)wxToy.ItemContainerGenerator.ContainerFromIndex(i);
        uiElement.DataContext = null;
        uiElement.UpdateLayout();
    }

    wxButton.Content = ++Counter;

    ToyList.Clear();

    // Update Images
    for (int i = 0; i < 5; i++)
    {
        ToyList.Add(new ToyItem());
    }

}