private static ImageFormat GetImageFormat(Image image, HSSettings settingsContext)
{
Debug.Assert(image != null);
Debug.Assert(settingsContext != null);
if (!settingsContext.EnableSmartFormatForUpload)
{
return(ImageFormat.Png);
}
if (!Drawing.ImageFormatAnalyser.IsOptimizable(image))
{
return(ImageFormat.Png);
}
try
{
var bmp = image is Bitmap b ? b : new Bitmap(image);
return(Drawing.ImageFormatAnalyser.GetBestFittingFormat(bmp)); // Experimental?
}
catch (Exception e)
{
Debug.Fail(e.Message);
return(ImageFormat.Png);
}
}
public static void OpenPictureSaveDirectory(HSSettings settingsContext)
{
var path = settingsContext.ExpandedSavePath;
if (string.IsNullOrWhiteSpace(path))
{
NotificationManager.NoPathSpecified();
return;
}
var ensuredDestinationDirectory = GetAndEnsureDestinationDirectory(settingsContext);
if (ensuredDestinationDirectory == null)
{
NotificationManager.PathDoesNotExist(path);
return;
}
if (!string.IsNullOrEmpty(_lastFileName) && File.Exists(_lastFileName))
{
HolzShotsPaths.OpenSelectedFileInExplorer(_lastFileName);
}
else
{
HolzShotsPaths.OpenFolderInExplorer(path);
}
}
public static UploaderEntry?GetUploadServiceForSettingsContext(HSSettings context, UploaderManager uploaderManager)
{
Debug.Assert(context != null);
Debug.Assert(uploaderManager != null);
Debug.Assert(uploaderManager.Loaded);
return(uploaderManager.GetUploaderByName(context.TargetImageHoster));
}
// private readonly string _displayUrl;
public UploadResultForm(UploadResult result, HSSettings settingsContext)
{
_result = result ?? throw new ArgumentNullException(nameof(result));
_settingsContext = settingsContext ?? throw new ArgumentNullException(nameof(settingsContext));
InitializeComponent();
StartPosition = FormStartPosition.Manual;
_animator = new FlyoutAnimator(this);
/*
* if (!string.IsNullOrEmpty(result.Url))
* _displayUrl = EnvironmentEx.ShortenViaEllipsisIfNeeded(result.Url, 26);
*/
}
public static void HandleScreenshot(Screenshot shot, HSSettings settingsContext)
{
// If Not settingsContext.SaveImagesToLocalDisk OrElse Not CheckSavePath(settingsContext) Then Return
if (!settingsContext.SaveToLocalDisk)
{
return;
}
var ensuredDestinationDirectory = GetAndEnsureDestinationDirectory(settingsContext);
if (ensuredDestinationDirectory == null)
{
return;
}
SaveScreenshot(shot, ensuredDestinationDirectory, settingsContext);
}
private void cleanButton_Click(object sender, RoutedEventArgs e)
{
Bitmap image = null;
if (algorithmsComboBox.SelectedItem.ToString() == "LSB")
{
// LSB is not reversible - do nothing
}
else if (algorithmsComboBox.SelectedItem.ToString() == "Histogram shifting")
{
HSSettings tab = settingsTabControl.SelectedContent as HSSettings;
int minIndex = tab.getMinIndex();
int maxIndex = tab.getMaxIndex();
image = HS.Instance.Clean(new Bitmap(carrierViewer.filename), minIndex, maxIndex);
}
ImageFormat format = ImageFormat.Png;
SaveFileDialog sfd = new SaveFileDialog();
string ext = System.IO.Path.GetExtension(carrierViewer.filename);
switch (ext)
{
case ".png":
sfd.Filter = "Save Format|*.png";
format = ImageFormat.Png;
break;
case ".jpg":
sfd.Filter = "Save Format|*.jpg";
format = ImageFormat.Jpeg;
break;
case ".bmp":
sfd.Filter = "Save Format|*.bmp";
format = ImageFormat.Bmp;
break;
}
if (sfd.ShowDialog() == true)
{
image.Save(sfd.FileName);
}
}
private static string?GetAndEnsureDestinationDirectory(HSSettings settingsContext)
{
var resolvedPath = settingsContext.ExpandedSavePath;
Debug.Assert(!string.IsNullOrEmpty(resolvedPath));
try
{
HolzShotsPaths.EnsureDirectory(resolvedPath);
return(resolvedPath);
}
catch (UnauthorizedAccessException)
{
NotificationManager.UnauthorizedAccessExceptionDirectory(resolvedPath);
return(null);
}
catch (PathTooLongException)
{
NotificationManager.PathIsTooLong(resolvedPath);
return(null);
}
}
public static async Task <Screenshot?> CaptureSelection(HSSettings settingsContext)
{
if (settingsContext == null)
{
throw new ArgumentNullException(nameof(settingsContext));
}
Debug.Assert(!SelectionSemaphore.IsInAreaSelection);
if (SelectionSemaphore.IsInAreaSelection)
{
return(null);
}
using var prio = new ProcessPriorityRequest();
var(screen, cursorPosition) = ScreenshotCreator.CaptureScreenshot(SystemInformation.VirtualScreen, settingsContext.CaptureCursor);
using var selector = AreaSelector.Create(screen, true, settingsContext);
var(selectedArea, _) = await selector.PromptSelectionAsync().ConfigureAwait(true);
Debug.Assert(selectedArea.Width > 0);
Debug.Assert(selectedArea.Height > 0);
var selectedImage = new Bitmap(selectedArea.Width, selectedArea.Height);
var cursorPositionOnSelectedImage = cursorPosition == null
? null
: cursorPosition with {
OnImage = new Point(cursorPosition.OnImage.X - selectedArea.X, cursorPosition.OnImage.Y - selectedArea.Y)
};
using var g = Graphics.FromImage(selectedImage);
g.DrawImage(screen, new Rectangle(0, 0, selectedArea.Width, selectedArea.Height), selectedArea, GraphicsUnit.Pixel);
return(Screenshot.FromImage(selectedImage, cursorPosition, ScreenshotSource.Selected));
}
}
public static void InvokeUploadFinishedUI(UploadResult result, HSSettings settingsContext)
{
Debug.Assert(result != null);
Debug.Assert(!string.IsNullOrWhiteSpace(result.Url));
switch (settingsContext.ActionAfterUpload)
{
case UploadHandlingAction.Flyout:
(new UploadResultForm(result, settingsContext)).Show();
break;
case UploadHandlingAction.CopyToClipboard:
{
var success = ClipboardEx.SetText(result.Url);
if (settingsContext.ShowCopyConfirmation)
{
if (success)
{
NotificationManager.ShowCopyConfirmation(result.Url);
}
else
{
NotificationManager.CopyingFailed(result.Url);
}
}
}
break;
case UploadHandlingAction.None:
// Intentionally left empty
break;
default:
// Intentionally left empty
break;
}
}
private static Screenshot?CaptureWindow(IntPtr windowHandle, HSSettings settingsContext, bool includeMargin = true)
{
if (Native.User32.IsIconic(windowHandle))
{
return(default);
protected override async Task InvokeInternal(IReadOnlyDictionary <string, string> parameters, HSSettings settingsContext)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
if (settingsContext == null)
{
throw new ArgumentNullException(nameof(settingsContext));
}
// TODO: Add proper assertion
// Debug.Assert(ManagedSettings.EnableAreaScreenshot)
Debug.Assert(!SelectionSemaphore.IsInAreaSelection);
if (!settingsContext.EnableHotkeysDuringFullscreen && HolzShots.Windows.Forms.EnvironmentEx.IsFullscreenAppRunning())
{
return;
}
// TODO: Re-add proper if condition
// If ManagedSettings.EnableAreaScreenshot AndAlso Not SelectionSemaphore.IsInAreaSelection Then
if (!SelectionSemaphore.IsInAreaSelection)
{
Screenshot?shot;
try
{
shot = await CaptureSelection(settingsContext).ConfigureAwait(true);
Debug.Assert(shot != null);
if (shot == null)
{
throw new TaskCanceledException();
}
}
catch (TaskCanceledException)
{
Debug.WriteLine("Area Selection cancelled");
return;
}
Debug.Assert(shot != null);
await ProcessCapturing(shot, settingsContext).ConfigureAwait(true);
}
}
public static async Task <UploadResult> InitiateUpload(IUploadPayload payload, HSSettings settingsContext, Uploader uploader, ITransferProgressReporter?progressReporter)
{
if (payload == null)
{
throw new ArgumentNullException(nameof(payload));
}
if (settingsContext == null)
{
throw new ArgumentNullException(nameof(settingsContext));
}
if (uploader == null)
{
throw new ArgumentNullException(nameof(uploader));
}
try
{
var sc = uploader.GetSupportedSettingsInvocations();
if ((sc & SettingsInvocationContexts.OnUse) == SettingsInvocationContexts.OnUse)
{
// A third-party settings dialog may throw an exception
// If it does, we abort the upload
await uploader.InvokeSettingsAsync(SettingsInvocationContexts.OnUse).ConfigureAwait(true);
}
using var ui = new UploadUI(payload, uploader, progressReporter);
try
{
ui.ShowUI();
return(await ui.InvokeUploadAsync().ConfigureAwait(true));
}
finally
{
ui.HideUI();
}
}
catch (OperationCanceledException c)
{
throw new UploadCanceledException(c);
}
catch (UploadException)
{
throw;
}
catch (Exception ex)
{
throw new UploadException(ex.Message, ex);
}
}
// TODO: maybe refactor this, so the payload gets created somewhere else
/// <summary> Catch the UploadException! </summary>
public static async Task <UploadResult> InitiateUpload(Image image, HSSettings settingsContext, Uploader uploader, ImageFormat?format, ITransferProgressReporter?progressReporter)
{
format ??= GetImageFormat(image, settingsContext);
using var payload = new ImageUploadPayload(image, format);
return(await InitiateUpload(payload, settingsContext, uploader, progressReporter));
}
public static Task <UploadResult> InitiateUploadToDefaultUploader(IUploadPayload payload, HSSettings settingsContext, UploaderManager uploaderManager, ITransferProgressReporter?progressReporter)
{
Debug.Assert(payload != null);
Debug.Assert(settingsContext != null);
Debug.Assert(uploaderManager != null);
var service = GetUploadServiceForSettingsContext(settingsContext, uploaderManager);
Debug.Assert(service is not null);
Debug.Assert(service.Metadata != null);
Debug.Assert(service.Uploader != null);
if (service?.Metadata == null || service?.Uploader == null)
{
throw new UploadException("Unable to find an uploader for the current settings context");
}
return(InitiateUpload(payload, settingsContext, service.Uploader, progressReporter));
}
private static void SaveScreenshot(Screenshot shot, string ensuredDestinationDirectory, HSSettings settingsContext)
{
var format = ImageFormat.Png;
var extensionAndMimeType = ImageFormatInformation.GetExtensionAndMimeType(format);
Debug.Assert(shot.Image.GetType() == typeof(Bitmap));
var screenshotImage = shot.Image.GetType() == typeof(Bitmap)
? shot.Image
: new Bitmap(shot.Image);
if (settingsContext.EnableSmartFormatForSaving && ImageFormatAnalyser.IsOptimizable(screenshotImage))
{
format = ImageFormatAnalyser.GetBestFittingFormat(screenshotImage);
extensionAndMimeType = format.GetExtensionAndMimeType();
Debug.Assert(!string.IsNullOrWhiteSpace(extensionAndMimeType.FileExtension));
}
var pattern = settingsContext.SaveImageFileNamePattern;
var patternData = shot.GetFileMetadata(format);
string name;
try
{
name = FileNamePatternFormatter.GetFileNameFromPattern(patternData, pattern);
}
catch (PatternSyntaxException)
{
NotificationManager.InvalidFilePattern(pattern);
return;
}
var fileName = Path.ChangeExtension(name, extensionAndMimeType.FileExtension);
var path = GetAbsolutePath(ensuredDestinationDirectory, fileName);
var freePath = FileEx.GetUnusedFileNameFromCandidate(path);
screenshotImage.Save(freePath, format);
_lastFileName = path;
}
// TODO: maybe refactor this, so the payload gets created somewhere else
/// <summary> Catch the UploadException! </summary>
public static async Task <UploadResult> InitiateUploadToDefaultUploader(Image image, HSSettings settingsContext, UploaderManager uploaderManager, ImageFormat?format, ITransferProgressReporter?progressReporter)
{
Debug.Assert(image != null);
Debug.Assert(settingsContext != null);
Debug.Assert(uploaderManager != null);
format ??= GetImageFormat(image, settingsContext);
using var payload = new ImageUploadPayload(image, format);
return(await InitiateUploadToDefaultUploader(payload, settingsContext, uploaderManager, progressReporter));
}
protected override async Task InvokeInternal(IReadOnlyDictionary <string, string> parameters, HSSettings settingsContext)
{
// TODO: Add proper assertion
// Debug.Assert(ManagedSettings.EnableFullscreenScreenshot)
// TODO: Re-add proper if condition
// If ManagedSettings.EnableFullscreenScreenshot Then
var shot = CaptureFullScreen(settingsContext);
Debug.Assert(shot != null);
await ProcessCapturing(shot, settingsContext).ConfigureAwait(true);
}
protected override async Task InvokeInternal(IReadOnlyDictionary <string, string> parameters, HSSettings settingsContext)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
if (settingsContext == null)
{
throw new ArgumentNullException(nameof(settingsContext));
}
var image = GetClipboardImage();
if (image == null)
{
return;
}
var shot = Screenshot.FromImage(image, null, ScreenshotSource.Clipboard);
await ProcessCapturing(shot, settingsContext).ConfigureAwait(true);
}
public static Screenshot CaptureFullScreen(HSSettings settingsContext)
{
using var prio = new ProcessPriorityRequest();
var(screen, cursorPosition) = ScreenshotCreator.CaptureScreenshot(SystemInformation.VirtualScreen, settingsContext.CaptureCursor);
return(Screenshot.FromImage(screen, cursorPosition, ScreenshotSource.Fullscreen));
}
private void decryptButton_Click(object sender, RoutedEventArgs e)
{
string message = null;
int imageHeight = 0;
int imageWidth = 0;
Bitmap drawnImage = null;
MessageType messageType = MessageType.Plaintext;
if (algorithmsComboBox.SelectedItem.ToString() == "LSB")
{
IOutputMessage messageInBits = LSB.Instance.Decode(new Bitmap(carrierViewer.filename));
messageType = messageInBits.GetHeaderData().GetMessageType();
string outputMessage = messageInBits.GetContent();
switch (messageType)
{
case MessageType.Plaintext:
message = AlgorithmUtility.bitMessageToText(outputMessage, (int)LSBHeaderConstants.PlainTextHeaderLength);
break;
case MessageType.BinaryImage:
message = outputMessage.Substring((int)LSBHeaderConstants.BinaryImageHeaderLength);
imageHeight = messageInBits.GetHeaderData().GetImageHeight();
imageWidth = messageInBits.GetHeaderData().GetImageWidth();
drawnImage = ImageDrawer.Instance.DrawBinaryImage(message, imageWidth, imageHeight);
break;
case MessageType.GrayscaleImage:
message = outputMessage.Substring((int)LSBHeaderConstants.GrayscaleImageHeaderLength);
imageHeight = messageInBits.GetHeaderData().GetImageHeight();
imageWidth = messageInBits.GetHeaderData().GetImageWidth();
drawnImage = ImageDrawer.Instance.DrawGrayscaleImage(message, imageWidth, imageHeight);
break;
case MessageType.ColorImage:
message = outputMessage.Substring((int)LSBHeaderConstants.ColorImageHeaderLength);
imageHeight = messageInBits.GetHeaderData().GetImageHeight();
imageWidth = messageInBits.GetHeaderData().GetImageWidth();
drawnImage = ImageDrawer.Instance.DrawColorImage(message, imageWidth, imageHeight);
break;
}
}
else if (algorithmsComboBox.SelectedItem.ToString() == "Histogram shifting")
{
HSSettings tab = settingsTabControl.SelectedContent as HSSettings;
int minIndex = tab.getMinIndex();
int maxIndex = tab.getMaxIndex();
IOutputMessage messageInBits = HS.Instance.Decode(new Bitmap(carrierViewer.filename), minIndex, maxIndex);
messageType = messageInBits.GetHeaderData().GetMessageType();
string outputMessage = messageInBits.GetContent();
switch (messageType)
{
case MessageType.Plaintext:
message = AlgorithmUtility.bitMessageToText(outputMessage, (int)HSHeaderConstants.PlainTextHeaderLength);
break;
case MessageType.BinaryImage:
message = outputMessage.Substring((int)HSHeaderConstants.BinaryImageHeaderLength);
imageHeight = messageInBits.GetHeaderData().GetImageHeight();
imageWidth = messageInBits.GetHeaderData().GetImageWidth();
drawnImage = ImageDrawer.Instance.DrawBinaryImage(message, imageWidth, imageHeight);
break;
case MessageType.GrayscaleImage:
message = outputMessage.Substring((int)HSHeaderConstants.GrayscaleImageHeaderLength);
imageHeight = messageInBits.GetHeaderData().GetImageHeight();
imageWidth = messageInBits.GetHeaderData().GetImageWidth();
drawnImage = ImageDrawer.Instance.DrawGrayscaleImage(message, imageWidth, imageHeight);
break;
case MessageType.ColorImage:
message = outputMessage.Substring((int)HSHeaderConstants.ColorImageHeaderLength);
imageHeight = messageInBits.GetHeaderData().GetImageHeight();
imageWidth = messageInBits.GetHeaderData().GetImageWidth();
drawnImage = ImageDrawer.Instance.DrawColorImage(message, imageWidth, imageHeight);
break;
}
}
// need to change this dynamically
if (messageType == MessageType.Plaintext)
{
messageTabControl.SelectedItem = messageTextBox;
TextBox tab = messageTabControl.SelectedContent as TextBox;
tab.Text = message;
//messageTextBox.selec = message;
}
else
{
messageTabControl.SelectedItem = messageImage;
Image tab = messageTabControl.SelectedContent as Image;
tab.Source = ToBitmapImage(drawnImage);
}
}
protected override async Task InvokeInternal(IReadOnlyDictionary <string, string> parameters, HSSettings settingsContext)
{
// TODO: Add proper assertion
// Debug.Assert(ManagedSettings.EnableWindowScreenshot)
// TODO: Re-add proper if condition
// If ManagedSettings.EnableWindowScreenshot Then
var h = Native.User32.GetForegroundWindow();
Native.User32.GetWindowPlacement(h, out Native.User32.WindowPlacement info);
var shot = CaptureWindow(h, settingsContext);
if (shot != null)
{
await ProcessCapturing(shot, settingsContext).ConfigureAwait(true);
}
}
public static ITransferProgressReporter GetUploadReporterForCurrentSettingsContext(HSSettings settingsContext, IWin32Window parentWindow)
{
var reporters = new List <ITransferProgressReporter>(4);
#if DEBUG
reporters.Add(new ConsoleProgressReporter());
#endif
if (settingsContext.ShowUploadProgress)
{
reporters.Add(new UploadStatusFlyoutForm());
}
if (parentWindow.GetHandle() != IntPtr.Zero)
{
reporters.Add(new TaskbarItemProgressReporter(parentWindow.Handle));
}
return(new AggregateProgressReporter(reporters));
}
