public enum AlphaDisplaySettings

{

[Description("Don't show Alpha")]

NoAlpha,

[Description("Alpha 'merged' (premult) with RGB")]

PremultiplyAlpha,

[Description("Alpha Only")]

AlphaOnly,

}

public class NewViewModel : ViewModelBase

{

Stopwatch operationElapsedTimer = new Stopwatch();

DispatcherTimer operationElapsedUpdateTimer = new DispatcherTimer();

DispatcherTimer busyTimer = new DispatcherTimer();

bool delayedBusy = false;

public bool DelayedBusy

{

get

{

return delayedBusy;

}

set

{

SetProperty(ref delayedBusy, value);

}

}

bool isWindowBlurred = true;

public bool IsWindowBlurred

{

get

{

return isWindowBlurred;

}

set

{

SetProperty(ref isWindowBlurred, value);

}

}

public bool IsCancellationRequested

{

get

{

return ImageEngine.IsCancellationRequested;

}

}

bool useHighQualityScaling = true;

public bool UseHighQualityScaling

{

get

{

return useHighQualityScaling;

}

set

{

SetProperty(ref useHighQualityScaling, value);

}

}

bool useSourceFormatForSaving = false;

public bool UseSourceFormatForSaving

{

get

{

return useSourceFormatForSaving;

}

set

{

SetProperty(ref useSourceFormatForSaving, value);

}

}

string status = null;

public string Status

{

get

{

return status;

}

set

{

SetProperty(ref status, value);

}

}

bool showHelpAbout = false;

public bool ShowHelpAbout

{

get

{

return showHelpAbout;

}

set

{

SetProperty(ref showHelpAbout, value);

}

}

bool isRedChannelOn = true;

public bool IsRedChannelOn

{

get

{

return isRedChannelOn;

}

set

{

SetProperty(ref isRedChannelOn, value);

if (IsImageLoaded)

SetChannel(Preview, value, 2);

}

}

bool isGreenChannelOn = true;

public bool IsGreenChannelOn

{

get

{

return isGreenChannelOn;

}

set

{

SetProperty(ref isGreenChannelOn, value);

if (IsImageLoaded)

SetChannel(Preview, value, 1);

}

}

bool isBlueChannelOn = true;

public bool IsBlueChannelOn

{

get

{

return isBlueChannelOn;

}

set

{

SetProperty(ref isBlueChannelOn, value);

if (IsImageLoaded)

SetChannel(Preview, value, 0);

}

}

#region Settings Panel Properties

bool settingsPanelOpen = false;

public bool SettingsPanelOpen

{

get

{

return settingsPanelOpen;

}

set

{

SetProperty(ref settingsPanelOpen, value);

}

}

public bool EnableThreading

{

get

{

return ImageEngine.EnableThreading;

}

set

{

ImageEngine.EnableThreading = value;

OnPropertyChanged(nameof(EnableThreading));

}

}

public bool UseWindowsCodecs

{

get

{

return ImageEngine.WindowsWICCodecsAvailable;

}

set

{

ImageEngine.WindowsWICCodecsAvailable = value;

OnPropertyChanged(nameof(UseWindowsCodecs));

}

}

public int NumThreads

{

get

{

return ImageEngine.NumThreads;

}

set

{

if (value < 1 && value != -1) // Allowed to be -1 for being infinite

return;

ImageEngine.NumThreads = value;

OnPropertyChanged(nameof(NumThreads));

if (NumThreads == 1)

EnableThreading = false;

}

}

#endregion Settings Panel Properties

#region Info Panel Properties

bool infoPanelOpen = false;

public bool InfoPanelOpen

{

get

{

return infoPanelOpen;

}

set

{

SetProperty(ref infoPanelOpen, value);

}

}

string cpuName = "Unknown";

public string CPUName

{

get

{

if (cpuName == "Unknown")

{

var searcher = new ManagementObjectSearcher("select * from Win32_Processor");

List<object> testting = new List<object>();

foreach (var item in searcher.Get())

{

cpuName = item["Name"].ToString();

break;

}

}

return cpuName;

}

}

public int NumCores

{

get

{

return System.Environment.ProcessorCount;

}

}

public bool Is64Bit

{

get

{

return System.Environment.Is64BitOperatingSystem;

}

}

public bool IsRunning64Bit

{

get

{

return System.Environment.Is64BitProcess;

}

}

string osVersion = "Unknown";

public string OSVersion

{

get

{

if (osVersion == "Unknown")

{

var name = (from x in new ManagementObjectSearcher("SELECT Caption FROM Win32_OperatingSystem").Get().Cast<ManagementObject>()

select x.GetPropertyValue("Caption")).FirstOrDefault();

osVersion = name != null ? name.ToString() : "Unknown";

}

return osVersion;

}

}

ulong ramSize = 0;

public ulong RAMSize

{

get

{

if (ramSize == 0)

{

var searcher = new ManagementObjectSearcher("select * from Win32_PhysicalMemory");

foreach (var item in searcher.Get())

ramSize += (ulong)item["Capacity"];

}

return ramSize;

}

}

string gpuName = "Unknown";

public string GPUName

{

get

{

if (gpuName == "Unknown")

{

var searcher = new ManagementObjectSearcher("select * from Win32_VideoController");

List<object> testting = new List<object>();

foreach (var item in searcher.Get())

{

gpuName = item["Name"].ToString();

break;

}

}

return gpuName;

}

}

#endregion Info Panel Properties

string saveDuration = null;

public string SaveDuration

{

get

{

return saveDuration;

}

set

{

SetProperty(ref saveDuration, value);

}

}

#region Commands

CommandHandler closeCommand = null;

public CommandHandler CloseCommand

{

get

{

if (closeCommand == null)

closeCommand = new CommandHandler(() => CloseImage(true));

return closeCommand;

}

}

CommandHandler saveCommand = null;

public CommandHandler SaveCommand

{

get

{

if (saveCommand == null)

saveCommand = new CommandHandler(() =>

{

Task.Run(async () =>

{

Status = "Saving...";

Busy = true;

try

{

if (SplitChannels)

LoadedImage.SplitChannels(SavePath);

else

await LoadedImage.Save(SavePath, SaveFormatDetails, SaveMipType, removeAlpha: GeneralRemovingAlpha);

}

catch (Exception e)

{

SaveError = e.ToString();

}

SaveAttempted = true;

Busy = false;

SaveDuration = $"{operationElapsedTimer.ElapsedMilliseconds}ms";

SavePath = UsefulThings.General.FindValidNewFileName(SavePath); // Ensure save path is pointing to a new valid filepath

});

});

return saveCommand;

}

}

#endregion Commands

#region Merge Channels Properties

bool mergePanelOpen = false;

public bool MergeChannelsPanelOpen

{

get

{

return mergePanelOpen;

}

set

{

SetProperty(ref mergePanelOpen, value);

}

}

public MTRangedObservableCollection<MergeChannelsImage> MergeChannelsImages { get; set; } = new MTRangedObservableCollection<MergeChannelsImage>();

public bool MergeChannelsReady

{

get

{

if (MergeChannelsImages.Count == 0)

return false;

var dimensions = MergeChannelsImages.Where(t => t.IsRed || t.IsAlpha || t.IsBlue || t.IsGreen);

if (dimensions.Count() == 0)

return false;

int width = dimensions.First().Width;

int height = dimensions.First().Height;

return dimensions.All(t => t.Width == width) && dimensions.All(t => t.Height == height);

}

}

#endregion Merge Channels Properties

#region General Properties

byte windowBackground_Red = 0;

public byte WindowBackground_Red

{

get

{

return windowBackground_Red;

}

set

{

SetProperty(ref windowBackground_Red, value);

OnPropertyChanged(nameof(WindowBackgroundColour));

}

}

byte windowBackground_Green = 0;

public byte WindowBackground_Green

{

get

{

return windowBackground_Green;

}

set

{

SetProperty(ref windowBackground_Green, value);

OnPropertyChanged(nameof(WindowBackgroundColour));

}

}

byte windowBackground_Blue = 0;

public byte WindowBackground_Blue

{

get

{

return windowBackground_Blue;

}

set

{

SetProperty(ref windowBackground_Blue, value);

OnPropertyChanged(nameof(WindowBackgroundColour));

}

}

byte windowBackground_Alpha = 158;

public byte WindowBackground_Alpha

{

get

{

return windowBackground_Alpha;

}

set

{

SetProperty(ref windowBackground_Alpha, value);

OnPropertyChanged(nameof(WindowBackgroundColour));

}

}

public Brush WindowBackgroundColour

{

get

{

return new SolidColorBrush(Color.FromArgb(WindowBackground_Alpha, WindowBackground_Red, WindowBackground_Green, WindowBackground_Blue));

}

}

bool splitChannels = false;

public bool SplitChannels

{

get

{

return splitChannels;

}

set

{

SetProperty(ref splitChannels, value);

if (value)

SaveFormat = ImageEngineFormat.PNG;

}

}

bool busy = false;

public bool Busy

{

get

{

return busy;

}

set

{

if (!operationElapsedTimer.IsRunning)

operationElapsedTimer.Restart();

if (!operationElapsedUpdateTimer.IsEnabled)

operationElapsedUpdateTimer.Start();

if (value && !busy)

busyTimer.Start();

else if (!value)

{

busyTimer.Stop();

DelayedBusy = false;

operationElapsedUpdateTimer.Stop();

operationElapsedTimer.Stop();

}

SetProperty(ref busy, value);

}

}

#region Alpha and Colour related Properties

bool GeneralRemovingAlpha

{

get

{

return SaveFormat == ImageEngineFormat.DDS_DXT1 ? DXT1AlphaRemove : RemoveGeneralAlpha;

}

}

uint aMask = 0xFF000000;

public uint AMask

{

get

{

return aMask;

}

set

{

SetProperty(ref aMask, value);

}

}

uint rMask = 0x00FF0000;

public uint RMask

{

get

{

return rMask;

}

set

{

SetProperty(ref rMask, value);

}

}

uint gMask = 0x0000FF00;

public uint GMask

{

get

{

return gMask;

}

set

{

SetProperty(ref gMask, value);

}

}

uint bMask = 0x000000FF;

public uint BMask

{

get

{

return bMask;

}

set

{

SetProperty(ref bMask, value);

}

}

#endregion Alpha and Colour related Properties

#region Bulk Convert Properties

public MTRangedObservableCollection<string> BulkConvertFiles { get; set; } = new MTRangedObservableCollection<string>();

public MTRangedObservableCollection<string> BulkConvertFailed { get; set; } = new MTRangedObservableCollection<string>();

string operationElapsed = null;

public string OperationElapsed

{

get

{

return operationElapsed;

}

set

{

SetProperty(ref operationElapsed, value);

}

}

bool bulkConvertOpen = false;

public bool BulkConvertOpen

{

get

{

return bulkConvertOpen;

}

set

{

SetProperty(ref bulkConvertOpen, value);

Debug.WriteLine("BulkConvertOpen: " + value);

}

}

bool bulkFolderBrowseRecurse = true;

public bool BulkFolderBrowseRecurse

{

get

{

return bulkFolderBrowseRecurse;

}

set

{

SetProperty(ref bulkFolderBrowseRecurse, value);

}

}

bool bulkConvertRunning = false;

public bool BulkConvertRunning

{

get

{

return bulkConvertRunning;

}

set

{

SetProperty(ref bulkConvertRunning, value);

}

}

bool bulkConvertFinished = false;

public bool BulkConvertFinished

{

get

{

return bulkConvertFinished;

}

set

{

SetProperty(ref bulkConvertFinished, value);

}

}

string bulkSaveFolder = ""; // Can't be null

public string BulkSaveFolder

{

get

{

return bulkSaveFolder;

}

set

{

SetProperty(ref bulkSaveFolder, value);

}

}

bool bulkUseSourceDestination = false;

public bool BulkUseSourceDestination

{

get

{

return bulkUseSourceDestination;

}

set

{

SetProperty(ref bulkUseSourceDestination, value);

}

}

string bulkStatus = "Ready";

public string BulkStatus

{

get

{

return bulkStatus;

}

set

{

SetProperty(ref bulkStatus, value);

}

}

int bulkProgressMax = 0;

public int BulkProgressMax

{

get

{

return bulkProgressMax;

}

set

{

SetProperty(ref bulkProgressMax, value);

}

}

int bulkProgressValue = 1;

public int BulkProgressValue

{

get

{

return bulkProgressValue;

}

set

{

SetProperty(ref bulkProgressValue, value);

}

}

#endregion Bulk Convert Properties

#region Loaded Image Properties

bool loadFailed = false;

public bool LoadFailed

{

get

{

return loadFailed;

}

set

{

// If loading fails, it's not busy anymore.

if (value)

Busy = false;

SetProperty(ref loadFailed, value);

}

}

string loadFailError = null;

public string LoadFailError

{

get

{

return loadFailError;

}

set

{

SetProperty(ref loadFailError, value);

}

}

bool isImageLoaded = false;

public bool IsImageLoaded

{

get

{

return isImageLoaded;

}

set

{

SetProperty(ref isImageLoaded, value);

Debug.WriteLine("IsImageLoaded: " + value);

}

}

public int MipWidth

{

get

{

if (MipIndex == LoadedImage?.MipMaps.Count)

return 0;

return LoadedImage?.MipMaps[MipIndex]?.Width ?? -1;

}

}

public int MipHeight

{

get

{

if (MipIndex == LoadedImage?.MipMaps.Count)

return 0;

return LoadedImage?.MipMaps[MipIndex]?.Height ?? -1;

}

}

int mipIndex = 0;

public int MipIndex

{

get

{

return mipIndex;

}

set

{

if (mipIndex == value)

return;

SetProperty(ref mipIndex, value);

OnPropertyChanged(nameof(MipWidth));

OnPropertyChanged(nameof(MipHeight));

if (IsImageLoaded)

UpdateLoadedPreview();

}

}

ImageEngineImage loadedImage = null;

public ImageEngineImage LoadedImage

{

get

{

return loadedImage;

}

set

{

SetProperty(ref loadedImage, value);

OnPropertyChanged(nameof(IsImageLoaded));

}

}

WriteableBitmap preview = null;

public WriteableBitmap Preview

{

get

{

return preview;

}

set

{

SetProperty(ref preview, value);

}

}

string windowTitle = "Image Engine";

public string WindowTitle

{

get

{

return windowTitle;

}

set

{

SetProperty(ref windowTitle, value);

}

}

string loadDuration = null;

public string LoadDuration

{

get

{

return loadDuration;

}

set

{

SetProperty(ref loadDuration, value);

}

}

public string LoadedPath

{

get

{

return LoadedImage?.FilePath;

}

}

public ImageEngineFormat LoadedFormat

{

get

{

return LoadedImage?.Format ?? ImageEngineFormat.Unknown;

}

}

public bool IsDX10Loaded

{

get

{

return LoadedImage?.Format == ImageEngineFormat.DDS_DX10;

}

}

public DDS_Header.DXGI_FORMAT LoadedDX10Format

{

get

{

return IsDX10Loaded ? ((DDS_Header)LoadedImage.Header).DX10_DXGI_AdditionalHeader.dxgiFormat : DDS_Header.DXGI_FORMAT.DXGI_FORMAT_UNKNOWN;

}

}

public int Width

{

get

{

return LoadedImage?.Width ?? -1;

}

}

public int Height

{

get

{

return LoadedImage?.Height ?? -1;

}

}

public int UncompressedSize

{

get

{

if (!IsImageLoaded)

return -1;

return ImageFormats.GetUncompressedSize(LoadedImage.Width, LoadedImage.Height, LoadedImage.NumberOfChannels, LoadedImage.NumMipMaps > 1);

}

}

public int LoadedCompressedSize

{

get

{

return LoadedImage?.CompressedSize ?? -1;

}

}

public int MipCount

{

get

{

return LoadedImage?.NumMipMaps ?? -1;

}

}

public string HeaderDetails

{

get

{

return LoadedImage?.Header?.ToString();

}

}

AlphaDisplaySettings alphaDisplaySetting = 0;

public AlphaDisplaySettings AlphaDisplaySetting

{

get

{

return alphaDisplaySetting;

}

set

{

SetProperty(ref alphaDisplaySetting, value);

if (IsImageLoaded)

{

UpdateLoadedPreview();

if (SavePanelOpen)