// Returns UploadResult on success, Exception on failure
public async Task <object> Save(IBitmapImage image, ImageFormats format)
{
var progressItem = new ImageUploadNotification();
_systemTray.ShowNotification(progressItem);
try
{
var uploadResult = await _imgUploader.Upload(image, format, progressItemProgress => progressItem.Progress = progressItemProgress);
var link = uploadResult.Url;
_recentList.Add(new UploadRecentItem(link, uploadResult.DeleteLink, _imgUploader));
progressItem.RaiseFinished(link);
return(uploadResult);
}
catch (Exception e)
{
progressItem.RaiseFailed();
return(e);
}
}
public void SetImage(IBitmapImage Bmp)
{
using var pngStream = new MemoryStream();
Bmp.Save(pngStream, ImageFormats.Png);
var pngClipboardData = new DataObject("PNG", pngStream);
using var whiteS = new Bitmap(Bmp.Width, Bmp.Height, PixelFormat.Format24bppRgb);
Image drawingImg;
if (Bmp is DrawingImage drawingImage)
{
drawingImg = drawingImage.Image;
}
else
{
drawingImg = Image.FromStream(pngStream);
}
using (var graphics = Graphics.FromImage(whiteS))
{
graphics.Clear(Color.White);
graphics.DrawImage(drawingImg, 0, 0, Bmp.Width, Bmp.Height);
}
// Add fallback for applications that don't support PNG from clipboard (eg. Photoshop or Paint)
pngClipboardData.SetData(DataFormats.Bitmap, whiteS);
Clipboard.Clear();
Clipboard.SetDataObject(pngClipboardData, true);
}
// Deprecated in v 2.3 with no error
static public Bitmap Rotate(Bitmap bitmap, float angle)
{
if (bitmap == null)
{
throw new ArgumentNullException();
}
if (angle < 0)
{
angle += 360;
}
if (angle != 0 && angle != 90 && angle != 180 && angle != 270)
{
throw new ArgumentException("Only -90, 0, 90, 180 or 270 degrees rotation is supported", "angle");
}
IBitmapImage imageBitmap = BitmapToIImageBitmap(bitmap);
try
{
return(Rotate(imageBitmap, angle));
}
finally
{
Marshal.FinalReleaseComObject(imageBitmap);
}
}
public async Task <UploadResult> Upload(IBitmapImage Image, ImageFormats Format, Action <int> Progress)
{
using var w = new WebClient { Proxy = _proxySettings.GetWebProxy() };
if (Progress != null)
{
w.UploadProgressChanged += (S, E) => Progress(E.ProgressPercentage);
}
w.Headers.Add("Authorization", await GetAuthorizationHeader());
NameValueCollection values;
using (var ms = new MemoryStream())
{
Image.Save(ms, Format);
values = new NameValueCollection
{
{ "image", Convert.ToBase64String(ms.ToArray()) }
};
}
var uploadResponse = await UploadValuesAsync <ImgurUploadResponse>(w, "https://api.imgur.com/3/upload.json", values);
if (!uploadResponse.Success)
{
throw new Exception("Response indicates Failure");
}
return(new UploadResult
{
Url = uploadResponse.Data.Link,
DeleteLink = $"https://api.imgur.com/3/image/{uploadResponse.Data.DeleteHash}"
});
}
public void DrawImage(IBitmapImage Image, Rectangle?Region, int Opacity = 100)
{
if (!(Image is DrawingImage drawingImage))
{
return;
}
var img = drawingImage.Image;
var region = Region ?? new Rectangle(Point.Empty, img.Size);
if (Opacity < 100)
{
var colormatrix = new ColorMatrix
{
Matrix33 = Opacity / 100.0f
};
var imgAttribute = new ImageAttributes();
imgAttribute.SetColorMatrix(colormatrix, ColorMatrixFlag.Default, ColorAdjustType.Bitmap);
_graphics.DrawImage(img, region, 0, 0, img.Width, img.Height, GraphicsUnit.Pixel, imgAttribute);
}
else
{
_graphics.DrawImage(img, region);
}
}
public CollectionService(
ISqlService sqlService,
ISqlService bgSqlService,
IAppSettingsHelper appSettingsHelper,
IDispatcherHelper dispatcher,
IBitmapFactory bitmapFactory,
IBitmapImage missingArtwork,
string localFilePrefix,
string artworkFilePath,
string artistArtworkFilePath)
{
_bgSqlService = bgSqlService;
_sqlService = sqlService;
_dispatcher = dispatcher;
_appSettingsHelper = appSettingsHelper;
_bitmapFactory = bitmapFactory;
_missingArtwork = missingArtwork;
_localFilePrefix = localFilePrefix;
_artworkFilePath = artworkFilePath;
_artistArtworkFilePath = artistArtworkFilePath;
Songs = new OptimizedObservableCollection <Song>();
Artists = new OptimizedObservableCollection <Artist>();
Albums = new OptimizedObservableCollection <Album>();
Playlists = new OptimizedObservableCollection <Playlist>();
PlaybackQueue = new OptimizedObservableCollection <QueueSong>();
ShufflePlaybackQueue = new OptimizedObservableCollection <QueueSong>();
}
public CollectionService(
ISqlService sqlService,
ISqlService bgSqlService,
IAppSettingsHelper appSettingsHelper,
IDispatcherHelper dispatcher,
IBitmapFactory bitmapFactory,
IBitmapImage missingArtwork,
string localFilePrefix,
string artworkFilePath,
string artistArtworkFilePath)
{
_bgSqlService = bgSqlService;
_sqlService = sqlService;
_dispatcher = dispatcher;
_appSettingsHelper = appSettingsHelper;
_bitmapFactory = bitmapFactory;
_missingArtwork = missingArtwork;
_localFilePrefix = localFilePrefix;
_artworkFilePath = artworkFilePath;
_artistArtworkFilePath = artistArtworkFilePath;
Songs = new OptimizedObservableCollection<Song>();
Artists = new OptimizedObservableCollection<Artist>();
Albums = new OptimizedObservableCollection<Album>();
Playlists = new OptimizedObservableCollection<Playlist>();
PlaybackQueue = new OptimizedObservableCollection<QueueSong>();
ShufflePlaybackQueue = new OptimizedObservableCollection<QueueSong>();
}
public IBitmapImage ScreenShotWindow(IWindow Window)
{
_systemTray.HideNotification();
if (Window.Handle == _platformServices.DesktopWindow.Handle)
{
return(ScreenShot.Capture(_settings.IncludeCursor));
}
try
{
IBitmapImage bmp = null;
if (_settings.ScreenShots.WindowShotTransparent)
{
bmp = ScreenShot.CaptureTransparent(Window, _settings.IncludeCursor);
}
// Capture without Transparency
return(bmp ?? ScreenShot.Capture(Window.Rectangle, _settings.IncludeCursor));
}
catch
{
return(null);
}
}
public Task Save(IBitmapImage Image, ImageFormats Format, string FileName)
{
try
{
var extension = Format.ToString().ToLower();
var fileName = _settings.GetFileName(extension, FileName);
Image.Save(fileName, Format);
_recentList.Add(new FileRecentItem(fileName, RecentFileType.Image));
// Copy path to clipboard only when clipboard writer is off
if (_settings.CopyOutPathToClipboard && !ServiceProvider.Get <ClipboardWriter>().Active)
{
fileName.WriteToClipboard();
}
_systemTray.ShowScreenShotNotification(fileName);
}
catch (Exception e)
{
_messageProvider.ShowException(e, _loc.NotSaved);
}
return(Task.CompletedTask);
}
protected void Draw(IEditableFrame Editor, IBitmapImage Image, PointF Position, SizeF?Size, int Opacity)
{
if (Image == null)
{
return;
}
var targetSize = Size ?? new Size(Image.Width, Image.Height);
try
{
//var point = GetPosition(new Size((int)Editor.Width, (int)Editor.Height), targetSize);
var destRect = new RectangleF(Position, targetSize);
Editor.DrawImage(Image, destRect, Opacity);
}
catch { }
finally
{
if (_disposeImages)
{
Image.Dispose();
}
}
}
/// <summary>
/// Rotate and/or flip bitmap
/// </summary>
/// <param name="bitmap">Image</param>
/// <param name="type">Operation</param>
/// <returns>Modified bitmap</returns>
static public Bitmap RotateFlip(Bitmap bitmap, RotationAngle angle, FlipAxis axis)
{
if (bitmap == null)
{
throw new ArgumentNullException();
}
IBitmapImage image = BitmapToIImageBitmap(bitmap);
try
{
IBitmapImage imageBitmap = BitmapToIImageBitmap(bitmap);
IBasicBitmapOps ops = (IBasicBitmapOps)imageBitmap;
if (angle != 0)
{
ops.Rotate((float)angle, InterpolationHint.InterpolationHintDefault, out imageBitmap);
Marshal.FinalReleaseComObject(ops);
ops = (IBasicBitmapOps)imageBitmap;
}
if (axis != FlipAxis.None)
{
ops.Flip((axis & FlipAxis.X) == FlipAxis.X, (axis & FlipAxis.Y) == FlipAxis.Y, out imageBitmap);
Marshal.FinalReleaseComObject(ops);
ops = (IBasicBitmapOps)imageBitmap;
}
return(IBitmapImageToBitmap(imageBitmap));
}
finally
{
Marshal.FinalReleaseComObject(image);
}
}
public async Task Save(IBitmapImage image, ImageFormats format, string fileName)
{
var response = await Save(image, format);
switch (response)
{
case UploadResult uploadResult:
var link = uploadResult.Url;
// Copy path to clipboard only when clipboard writer is off
if (_settings.CopyOutPathToClipboard && !ServiceProvider.Get <ClipboardWriter>().Active)
{
link.WriteToClipboard();
}
break;
case Exception e:
if (!_diskWriter.Active)
{
ServiceProvider.Get <IMainWindow>().IsVisible = true;
var yes = _messageProvider.ShowYesNo(
$"{e.Message}\n\nDo you want to Save to Disk?", _loc.ImageUploadFailed);
if (yes)
{
await _diskWriter.Save(image, format, fileName);
}
}
break;
}
}
public Task Save(IBitmapImage image, ImageFormats format, string fileName)
{
_clipboard.SetImage(image);
_systemTray.ShowNotification(new TextNotification(_loc.ImgSavedClipboard));
return(Task.CompletedTask);
}
public Task Save(IBitmapImage Image, ImageFormats Format, string FileName)
{
_clipboard.SetImage(Image);
_systemTray.ShowNotification(new TextNotification("图片已复制到剪贴板"));
return(Task.CompletedTask);
}
public static bool SetBitmapPalette(IBitmapImage bitmap, ColorPalette palette)
{
if (bitmap == null)
{
throw new ArgumentNullException();
}
return(bitmap.SetPalette(palette.ConvertToMemory()) == 0);
}
/// <summary>
/// Create a bitmap image from an IImage object
/// </summary>
/// <param name="image"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="pixelFormat"></param>
/// <param name="hints"></param>
/// <param name="bitmap"></param>
/// <returns></returns>
public virtual extern int CreateBitmapFromImage(
IImage image,
uint width,
uint height,
PixelFormat pixelFormat,
InterpolationHint hints,
out IBitmapImage bitmap
);
public Task Save(IBitmapImage Image, ImageFormats Format, string FileName)
{
if (!File.Exists(FileName))
{
Image.Save(FileName, Format);
}
var winserv = ServiceProvider.Get <IMainWindow>();
winserv.EditImage(FileName);
return(Task.CompletedTask);
}
public IBitmapImage Capture(IBitmapLoader BitmapLoader)
{
if (_syncContext == null)
{
return(_captureWebcam.GetFrame(BitmapLoader));
}
IBitmapImage image = null;
_syncContext.Run(() => image = _captureWebcam.GetFrame(BitmapLoader));
return(image);
}
public void DrawImage(IBitmapImage Image, RectangleF?Region, int Opacity = 100)
{
if (Image is Direct2DImage direct2DImage)
{
var bmp = direct2DImage.Bitmap;
var rect = Region ?? new RectangleF(0, 0, bmp.Size.Width, bmp.Size.Height);
var rawRect = new RawRectangleF(rect.Left,
rect.Top,
rect.Right,
rect.Bottom);
_editorSession.RenderTarget.DrawBitmap(bmp, rawRect, Opacity, BitmapInterpolationMode.Linear);
}
}
private static Bitmap Rotate(IBitmapImage image, float angle)
{
IBitmapImage imageBitmap;
Bitmap bmRet;
IBasicBitmapOps ops = (IBasicBitmapOps)image;
ops.Rotate(angle, InterpolationHint.InterpolationHintDefault, out imageBitmap);
try
{
bmRet = IBitmapImageToBitmap(imageBitmap);
}
finally
{
Marshal.FinalReleaseComObject(imageBitmap);
}
return(bmRet);
}
public Task Save(IBitmapImage image, ImageFormats format, string fileName)
{
using (var stream = new MemoryStream())
{
image.Save(stream, ImageFormats.Png);
var decoder = new PngBitmapDecoder(stream, BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
var win = new ImageEditorWindow();
win.Open(decoder.Frames[0]);
win.Show();
}
return(Task.CompletedTask);
}
/// <summary>
/// Flips image around X and/or Y axes
/// </summary>
/// <param name="bitmap">Image</param>
/// <param name="axis">Axis or axes to flip on</param>
private static Bitmap Flip(IBitmapImage image, FlipAxis axis)
{
Bitmap bmRet;
IBitmapImage imageBitmap;
IBasicBitmapOps ops = (IBasicBitmapOps)image;
ops.Flip((axis & FlipAxis.X) == FlipAxis.X, (axis & FlipAxis.Y) == FlipAxis.Y, out imageBitmap);
try
{
bmRet = IBitmapImageToBitmap(imageBitmap);
}
finally
{
Marshal.FinalReleaseComObject(imageBitmap);
}
return(bmRet);
}
public async Task SaveScreenShot(IBitmapImage Bmp, string FileName = null)
{
_audioPlayer.Play(SoundKind.Shot);
if (Bmp != null)
{
var allTasks = AvailableImageWriters
.Where(M => M.Active)
.Select(M => M.Save(Bmp, _settings.ScreenShots.ImageFormat, FileName));
await Task.WhenAll(allTasks).ContinueWith(T => Bmp.Dispose());
}
else
{
_systemTray.ShowNotification(new TextNotification(_loc.ImgEmpty));
}
}
/// <summary>
/// Flips image around X and/or Y axes
/// </summary>
/// <param name="bitmap">Image</param>
/// <param name="axis">Axis or axes to flip on</param>
static public Bitmap Flip(Bitmap bitmap, FlipAxis axis)
{
if (bitmap == null)
{
throw new ArgumentNullException();
}
IBitmapImage image = BitmapToIImageBitmap(bitmap);
try
{
return(Flip(image, axis));
}
finally
{
Marshal.FinalReleaseComObject(image);
}
}
/// <summary>
/// Rotates image by specified amount of degrees
/// </summary>
/// <param name="bitmap">Image</param>
/// <param name="angle">Amount of degrees to rotate image by. Must be 90, 180, or 270</param>
/// <returns>Rotated image</returns>
static public Bitmap Rotate(Bitmap bitmap, RotationAngle angle)
{
if (bitmap == null)
{
throw new ArgumentNullException();
}
IBitmapImage imageBitmap = BitmapToIImageBitmap(bitmap);
try
{
return(Rotate(imageBitmap, (float)angle));
}
finally
{
Marshal.FinalReleaseComObject(imageBitmap);
}
}
public static string RenderTemplate(string imagePath)
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
Pulse.Extensions.RenderOptions ro = new Pulse.Extensions.RenderOptions();
ro.Height = 300;
ro.Width = 300;
myImage = PulseEmbComExtensions.Render(myDesign, ro);
myImage.Save(imagePath, ImageTypes.itAuto);
stopWatch.Stop();
TimeSpan ts = stopWatch.Elapsed;
string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
ts.Hours, ts.Minutes, ts.Seconds,
ts.Milliseconds / 10);
return(elapsedTime);
}
public static ColorPalette GetBitmapPalette(IBitmapImage bitmap)
{
if (bitmap == null)
{
throw new ArgumentNullException();
}
IntPtr pPalette;
if (bitmap.GetPalette(out pPalette) != 0)
{
return(null);
}
ColorPalette palette = new ColorPalette();
palette.ConvertFromMemory(pPalette);
Marshal.FreeCoTaskMem(pPalette);
return(palette);
}
public static Bitmap IBitmapImageToBitmap(IBitmapImage imageBitmap)
{
if (imageBitmap == null)
throw new ArgumentNullException();
Size size;
imageBitmap.GetSize(out size);
Rectangle rect = new Rectangle(0, 0, size.Width, size.Height);
BitmapData lockedBitmapData = new BitmapData();
imageBitmap.LockBits(ref rect, 0U, PixelFormatID.PixelFormat16bppRGB565, out lockedBitmapData);
Bitmap bitmap = new Bitmap((int)lockedBitmapData.Width, (int)lockedBitmapData.Height,
PixelFormat.Format16bppRgb565);
System.Drawing.Imaging.BitmapData bitmapdata = bitmap.LockBits(
new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.WriteOnly,
PixelFormat.Format16bppRgb565);
ImageHelpers.CopyMemory(bitmapdata.Scan0, lockedBitmapData.Scan0, (int)(lockedBitmapData.Height * lockedBitmapData.Stride));
imageBitmap.UnlockBits(ref lockedBitmapData);
bitmap.UnlockBits(bitmapdata);
return bitmap;
}
private void LoadImage(ImageChangedArgs imageArgs)
{
try
{
//Set the thumbnail
IBitmapImage ibi = ImageUtils.CreateThumbnail(imageArgs.Stream, this.pbThumbnail.Size);
Bitmap bmpThumb = ImageUtils.IBitmapImageToBitmap(ibi);
this.pbThumbnail.Image = bmpThumb;
//Set the image
ibi = ImageUtils.CreateThumbnail(imageArgs.Stream, imageArgs.Image.Size);
bmpThumb = ImageUtils.IBitmapImageToBitmap(ibi);
this.imageViewer1.Image = bmpThumb;
}
catch
{
this.pbThumbnail.Image = null;
}
}
static public IBitmapImage CreateThumbnail(Stream stream, Size size)
{
if (stream == null)
{
throw new ArgumentNullException();
}
ImagingFactory factory = new ImagingFactoryClass();
IImage image, imageThumb;
factory.CreateImageFromStream(new StreamOnFile(stream), out image);
image.GetThumbnail((uint)size.Width, (uint)size.Height, out imageThumb);
IBitmapImage imageBitmap = null;
ImageInfo ii;
image.GetImageInfo(out ii);
factory.CreateBitmapFromImage(image, (uint)size.Width, (uint)size.Height, ii.PixelFormat, InterpolationHint.InterpolationHintDefault, out imageBitmap);
return(imageBitmap);
}
public static async Task UploadImage(this IBitmapImage bitmap)
{
var uploadWriter = ServiceProvider.Get <ImageUploadWriter>();
var settings = ServiceProvider.Get <Settings.Settings>();
var response = await uploadWriter.Save(bitmap, settings.ScreenShots.ImageFormat);
switch (response)
{
case Exception ex:
var loc = ServiceProvider.Get <LanguageManager>();
ServiceProvider.MessageProvider.ShowException(ex, loc.ImageUploadFailed);
break;
case UploadResult uploadResult:
uploadResult.Url.WriteToClipboard();
break;
}
}
static public IBitmapImage CreateGrayScaleImage(Stream stream)
{
ImagingFactory factory = new ImagingFactoryClass();
IImage image;
factory.CreateImageFromStream(new StreamOnFile(stream), out image);
ImageInfo ii;
image.GetImageInfo(out ii);
image.SetImageFlags((ImageFlags)((int)ii.Flags & (int)ImageFlags.ImageFlagsColorSpaceGRAY));
IBitmapImage imageBitmap = null;
try
{
factory.CreateBitmapFromImage(image, (uint)ii.Width, (uint)ii.Height, ii.PixelFormat, InterpolationHint.InterpolationHintDefault, out imageBitmap);
}
catch { }
return(imageBitmap);
}
public uint CreateBitmapFromImage(IImage image, uint width, uint height, PixelFormatID pixelFormat, InterpolationHint hints, out IBitmapImage bitmap)
{
throw new NotImplementedException();
}
public uint CreateNewBitmap(uint width, uint height, PixelFormatID pixelFormat, out IBitmapImage bitmap)
{
throw new NotImplementedException();
}
