|
public OpenAsync ( [ accessMode ) : IAsyncOperation |
||
| accessMode | [ | |
| 리턴 | IAsyncOperation |
|
private async void openMyCamera()
{
CameraCaptureUI cameraUI = new CameraCaptureUI();
cameraUI.PhotoSettings.AllowCropping = false;
cameraUI.PhotoSettings.MaxResolution = CameraCaptureUIMaxPhotoResolution.MediumXga;
Windows.Storage.StorageFile capturedMedia =
await cameraUI.CaptureFileAsync(CameraCaptureUIMode.Photo);
if (capturedMedia != null)
{
using (var streamCamera = await capturedMedia.OpenAsync(FileAccessMode.Read))
{
bitmapCamera = new BitmapImage();
bitmapCamera.SetSource(streamCamera);
//To display the image in a XAML image object, do this:
imagePreivew.Source = bitmapCamera;
// Convert the camera bitap to a WriteableBitmap object,
// which is often a more useful format.
int width = bitmapCamera.PixelWidth;
int height = bitmapCamera.PixelHeight;
WriteableBitmap wBitmap = new WriteableBitmap(width, height);
using (var stream = await capturedMedia.OpenAsync(FileAccessMode.Read))
{
wBitmap.SetSource(stream);
}
SaveImageAsJpeg(wBitmap);
}
}
}
/// <summary>
/// Write the location metadata to the image file
/// </summary>
public async static Task WriteSurveyPhotoMetaData(StorageFile file, Geoposition pos, string surveyId = "")
{
using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
var decoder = await BitmapDecoder.CreateAsync(stream);
var encoder = await BitmapEncoder.CreateForTranscodingAsync(stream, decoder);
// Write the gps data
var propertySet = new BitmapPropertySet();
var latitudeNumerator = new BitmapTypedValue(CoordDoubleToIntArray(pos.Coordinate.Latitude), PropertyType.Int32Array);
var latitudeRef = new BitmapTypedValue("N", PropertyType.String);
var longitudeNumerator = new BitmapTypedValue(CoordDoubleToIntArray(pos.Coordinate.Longitude), PropertyType.Int32Array);
var longitudeRef = new BitmapTypedValue("W", PropertyType.String);
propertySet.Add("System.GPS.LatitudeNumerator", latitudeNumerator);
propertySet.Add("System.GPS.LatitudeRef", latitudeRef);
propertySet.Add("System.GPS.LatitudeDenominator", new BitmapTypedValue(new [] { 1, 1, 10000 }, PropertyType.Int32Array));
propertySet.Add("System.GPS.LongitudeNumerator", longitudeNumerator);
propertySet.Add("System.GPS.LongitudeRef", longitudeRef);
propertySet.Add("System.GPS.LongitudeDenominator", new BitmapTypedValue(new[] { 1, 1, 10000 }, PropertyType.Int32Array));
// Write the surveyId data
if (!string.IsNullOrEmpty(surveyId))
{
var surveyIdTyped = new BitmapTypedValue(surveyId, Windows.Foundation.PropertyType.String);
propertySet.Add("System.Comment", surveyIdTyped);
}
await encoder.BitmapProperties.SetPropertiesAsync(propertySet);
await encoder.FlushAsync();
}
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
/*参考文档: https://docs.microsoft.com/zh-cn/windows/uwp/files/quickstart-using-file-and-folder-pickers */
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail;
picker.SuggestedStartLocation =
Windows.Storage.Pickers.PickerLocationId.PicturesLibrary;
picker.FileTypeFilter.Add("*");
Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile imagefile = await storageFolder.CreateFileAsync("avatar", CreationCollisionOption.ReplaceExisting);
imagefile = await picker.PickSingleFileAsync();
if (imagefile != null) //若选中了图片，则将该图片填充头像，并保存图像地址
{
imgpath = imagefile.Path;
localSettings.Containers[username.Text].Values["avatar"] = imgpath;
ImageBrush brush = new ImageBrush();
BitmapImage bitmap = new BitmapImage();
using (var stream = await imagefile.OpenAsync(FileAccessMode.ReadWrite)) //需要使用文件流才能访问storagefile图片路径
{
bitmap.SetSource(stream);
}
brush.ImageSource = bitmap;
Avator.Fill = brush;
}
}
private async System.Threading.Tasks.Task pp_TappedAsync()
{
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail;
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary;
picker.FileTypeFilter.Add(".jpg");
picker.FileTypeFilter.Add(".jpeg");
picker.FileTypeFilter.Add(".png");
Windows.Storage.StorageFile file = await picker.PickSingleFileAsync();
if (file != null)
{
// Ensure the stream is disposed once the image is loaded
using (IRandomAccessStream fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read))
{
// Set the image source to the selected bitmap
BitmapImage bitmapImage = new BitmapImage();
await bitmapImage.SetSourceAsync(fileStream);
pp.ProfilePicture = bitmapImage;
}
}
}
private async void Open_Click(object sender, RoutedEventArgs e)
{
open.IsChecked = false;
Windows.Storage.Pickers.FileOpenPicker openPicker = new Windows.Storage.Pickers.FileOpenPicker();
openPicker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary;
openPicker.FileTypeFilter.Add(".gif");
Windows.Storage.StorageFile file = await openPicker.PickSingleFileAsync();
if (file != null)
{
Windows.Storage.Streams.IRandomAccessStream stream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read);
using (var inputStream = stream.GetInputStreamAt(0))
{
await canvas.InkPresenter.StrokeContainer.LoadAsync(inputStream);
}
stream.Dispose();
alreadySaved = true;
lastFile = file;
}
}
private async void ImagePiker_Click(object sender, RoutedEventArgs e)
{
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail;
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary;
picker.FileTypeFilter.Add(".jpg");
picker.FileTypeFilter.Add(".jpeg");
picker.FileTypeFilter.Add(".png");
Windows.Storage.StorageFile file = await picker.PickSingleFileAsync();
if (file != null)
{
// Application now has read/write access to the picked file
IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.Read);
BitmapImage bitmap = new BitmapImage();
bitmap.SetSource(stream);
this.Picture.Source = bitmap;
}
else
{
this.Picture.Source = null;
}
}
private async void OpenShitBtn_Click(object sender, RoutedEventArgs e)
{
//выбор файла
Windows.Storage.Pickers.FileOpenPicker open =
new Windows.Storage.Pickers.FileOpenPicker();
open.SuggestedStartLocation =
Windows.Storage.Pickers.PickerLocationId.DocumentsLibrary;
open.FileTypeFilter.Add(".rtf");
// собсно открытие файла
Windows.Storage.StorageFile file = await open.PickSingleFileAsync();
if (file != null)//не даст словить NRE и похожую дичь
{
using (Windows.Storage.Streams.IRandomAccessStream randAccStream =
await file.OpenAsync(Windows.Storage.FileAccessMode.Read))
{
// грузит содержимое файла в нашу коробычку
ShitEditor.Document.LoadFromStream(Windows.UI.Text.TextSetOptions.FormatRtf, randAccStream);
}
}
else //если дичь таки произошла
{
Windows.UI.Popups.MessageDialog errorBox =
new Windows.UI.Popups.MessageDialog("Начальника, всё сломався!");
await errorBox.ShowAsync();
}
}
private async void UploadButton_Click(object sender, RoutedEventArgs e)
{
//do whatever you need.
Canvas.SetZIndex(UploadGrid, 3);
Canvas.SetZIndex(GoalGrid, 1);
Canvas.SetZIndex(MapGrid, 1);
Page_Title.Text = "Upload";
Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
try
{
Windows.Storage.StorageFile saveFile = await storageFolder.GetFileAsync("save.png");
var bitmap = new BitmapImage(new Uri(saveFile.Path));
var Stream = await saveFile.OpenAsync(Windows.Storage.FileAccessMode.Read);
bitmap.SetSource(Stream);
img.Source = bitmap;
}
catch (Exception)
{
}
}
//We use a protected override void to execute code as soon as the page is loaded into memory
protected async override void OnNavigatedTo(NavigationEventArgs e)
{
Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile signInInfo = await storageFolder.CreateFileAsync("signin.txt", Windows.Storage.CreationCollisionOption.OpenIfExists);
var stream = await signInInfo.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
ulong size = stream.Size;
using (var inputStream = stream.GetInputStreamAt(0))
{
using (var dataReader = new Windows.Storage.Streams.DataReader(inputStream))
{
uint numBytesLoaded = await dataReader.LoadAsync((uint)size);
string signinAddress = dataReader.ReadString(numBytesLoaded);
//string currentUser = emailBox.Text;
if (signinAddress.ToString() == "")
{
emailBox.Text = "@wh-at.net";
}
else
{
emailBox.Text = signinAddress.ToString();
Frame.Navigate(typeof(helpdesk));
}
}
}
stream.Dispose();
}
async Task<RenderTargetBitmap> SaveToFileAsync(FrameworkElement uielement, StorageFile file)
{
if (file != null)
{
CachedFileManager.DeferUpdates(file);
Guid encoderId = GetBitmapEncoder(file.FileType);
try
{
using (var stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
return await CaptureToStreamAsync(uielement, stream, encoderId);
}
}
catch (Exception ex)
{
DisplayMessage(ex.Message);
}
var status = await CachedFileManager.CompleteUpdatesAsync(file);
}
return null;
}
private async void filePick_Click(object sender, RoutedEventArgs e)
{
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail;
picker.SuggestedStartLocation =
Windows.Storage.Pickers.PickerLocationId.VideosLibrary;
picker.FileTypeFilter.Add(".mp3");
picker.FileTypeFilter.Add(".mp4");
Windows.Storage.StorageFile file = await picker.PickSingleFileAsync();
if (file != null)
{
var stream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read);
mediaElement.SetSource(stream, file.ContentType);
mediaElement.Play();
mediaElement.AreTransportControlsEnabled = true;
Debug.WriteLine("Playing: " + file.Name);
}
else
{
Debug.WriteLine("Operation cancelled.");
}
}
private async void LoadMedia()
{
Media media = this.ViewModel.StoryBoard.MediaSource as Media;
Windows.Storage.StorageFile file = await Windows.Storage.StorageFile.GetFileFromPathAsync(media.SourcePath);
if (file != null)
{
var stream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read);
MediaSource mediaSource = MediaSource.CreateFromStream(stream, file.ContentType);
mediaSource.OpenOperationCompleted += MediaSource_OpenOperationCompleted;
this._mediaPlayer.Source = mediaSource;
this._mediaPlayer.CommandManager.IsEnabled = false;
this._mediaPlayer.TimelineController = _mediaTimelineController;
this._mediaPlayerElement.SetMediaPlayer(this._mediaPlayer);
DispatcherTimer timer = new DispatcherTimer();
timer.Interval = TimeSpan.FromSeconds(1);
timer.Tick += Timer_Tick;
timer.Start();
timeLine.Value = _mediaTimelineController.Position.TotalSeconds;
lowerTime.Text = GenTimeSpanFromSeconds(Math.Round(RangeSelectorControl.RangeMin));
upperTime.Text = GenTimeSpanFromSeconds(Math.Round(RangeSelectorControl.RangeMax));
}
}
public static async Task OutputSensorDataAsync()
{
// ファイルの作成 すでに存在する場合は置き換える
Windows.Storage.StorageFolder documentsLibrary = KnownFolders.DocumentsLibrary;
Windows.Storage.StorageFile file = await documentsLibrary.CreateFileAsync(sensorDataFileName, Windows.Storage.CreationCollisionOption.ReplaceExisting);
// ファイルへの書き込み
var stream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
using (var outputStream = stream.GetOutputStreamAt(0))
{
using (var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream))
{
dataWriter.WriteString("valueX valueY valueZ time\n");
if (Sensor_Values_Record_Time_List != null)
{
for (int i = 0; i < Sensor_Values_Record_Time_List.Count; i++)
{
dataWriter.WriteString($"{Math.Round(Sensor_ValueX_List[i], 3)} {Math.Round(Sensor_ValueY_List[i], 3)} {Math.Round(Sensor_ValueZ_List[i], 3)} {Math.Round(Sensor_Values_Record_Time_List[i], 2)}\n");
}
}
await dataWriter.StoreAsync();
await outputStream.FlushAsync();
}
}
stream.Dispose(); // Or use the stream variable (see previous code snippet) with a using statement as well.
}
/// <summary>
/// Triggered when the Capture Photo button is clicked by the user
/// </summary>
private async void Capture_Click(object sender, RoutedEventArgs e)
{
// Hide the capture photo button
CaptureButton.Visibility = Visibility.Collapsed;
// Capture current frame from webcam, store it in temporary storage and set the source of a BitmapImage to said photo
currentIdPhotoFile = await webcam.CapturePhoto();
var photoStream = await currentIdPhotoFile.OpenAsync(FileAccessMode.ReadWrite);
BitmapImage idPhotoImage = new BitmapImage();
await idPhotoImage.SetSourceAsync(photoStream);
// Set the soruce of the photo control the new BitmapImage and make the photo control visible
IdPhotoControl.Source = idPhotoImage;
IdPhotoControl.Visibility = Visibility.Visible;
// Collapse the webcam feed or disabled feed grid. Make the enter user name grid visible.
WebcamFeed.Visibility = Visibility.Collapsed;
DisabledFeedGrid.Visibility = Visibility.Collapsed;
UserNameGrid.Visibility = Visibility.Visible;
// Dispose photo stream
photoStream.Dispose();
}
private async void SelectPicture(object sender, RoutedEventArgs e)
{
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail;
picker.SuggestedStartLocation =
Windows.Storage.Pickers.PickerLocationId.PicturesLibrary;
picker.FileTypeFilter.Add(".jpg");
picker.FileTypeFilter.Add(".jpeg");
picker.FileTypeFilter.Add(".png");
Windows.Storage.StorageFile file = await picker.PickSingleFileAsync();
if (file != null)
{
IRandomAccessStream fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read);
BitmapImage bitmapImage = new BitmapImage();
bitmapImage.DecodePixelWidth = 350;
bitmapImage.DecodePixelHeight = 180;
await bitmapImage.SetSourceAsync(fileStream);
background.Source = bitmapImage;
}
}
async void OnSaveAsync(object sender, RoutedEventArgs e)
{
// We don't want to save an empty file
if (inkCanvas.InkPresenter.StrokeContainer.GetStrokes().Count > 0)
{
var savePicker = new Windows.Storage.Pickers.FileSavePicker();
savePicker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary;
savePicker.FileTypeChoices.Add("Gif with embedded ISF", new System.Collections.Generic.List <string> {
".gif"
});
Windows.Storage.StorageFile file = await savePicker.PickSaveFileAsync();
if (null != file)
{
try
{
using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
await inkCanvas.InkPresenter.StrokeContainer.SaveAsync(stream);
}
rootPage.NotifyUser(inkCanvas.InkPresenter.StrokeContainer.GetStrokes().Count + " stroke(s) saved!", NotifyType.StatusMessage);
}
catch (Exception ex)
{
rootPage.NotifyUser(ex.Message, NotifyType.ErrorMessage);
}
}
}
else
{
rootPage.NotifyUser("There is no ink to save.", NotifyType.ErrorMessage);
}
}
/// <summary>
/// This function would display the Image
/// </summary>
public async Task DisplayImageFileAsync(StorageFile file)
{
// Display the image in the UI.
BitmapImage src = new BitmapImage();
src.SetSource(await file.OpenAsync(FileAccessMode.Read));
Image1.Source = src;
}
public async void selectPic(Image pic)
{
var fop = new FileOpenPicker();
fop.ViewMode = PickerViewMode.Thumbnail;
fop.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
fop.FileTypeFilter.Add(".jpg");
fop.FileTypeFilter.Add(".jpeg");
fop.FileTypeFilter.Add(".png");
fop.FileTypeFilter.Add(".gif");
Windows.Storage.StorageFile file = await fop.PickSingleFileAsync();
try
{
using (IRandomAccessStream fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read))
{
BitmapImage bitmapImage = new BitmapImage();
await bitmapImage.SetSourceAsync(fileStream);
pic.Source = bitmapImage;
imgName = file.Path.Substring(file.Path.LastIndexOf('\\') + 1);
await file.CopyAsync(ApplicationData.Current.LocalFolder, imgName, NameCollisionOption.ReplaceExisting);
Debug.WriteLine(imgName);
}
}
catch (Exception)
{
return;
}
}
/// <summary>
/// Saves the specified bitmap to the specified location.
/// </summary>
/// <param name="source">The source bitmap image.</param>
/// <param name="destination">The destination storage file for the image. JPEG, PNG, GIF, BMP and TIFF formats are supported.</param>
/// <param name="width">The width of the image file.</param>
/// <param name="height">The height of the image file.</param>
/// <returns>True if the bitmap file was successfully saved. False otherwise.</returns>
public async Task<bool> Save(WriteableBitmap source, StorageFile destination, int width, int height)
{
if (source == null || destination == null) return false;
try
{
Guid encoderID = GetEncoderId(destination);
using (IRandomAccessStream stream = await destination.OpenAsync(FileAccessMode.ReadWrite))
{
Stream pixelStream = source.PixelBuffer.AsStream();
byte[] pixels = new byte[pixelStream.Length];
await pixelStream.ReadAsync(pixels, 0, pixels.Length);
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(encoderID, stream);
encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, (uint)source.PixelWidth, (uint)source.PixelHeight, Constants.DPI, Constants.DPI, pixels);
if (source.PixelWidth != width || source.PixelHeight != height)
{
encoder.BitmapTransform.ScaledWidth = (uint)width;
encoder.BitmapTransform.ScaledHeight = (uint)height;
}
await encoder.FlushAsync();
}
return true;
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
return false;
}
async Task saveDebugImage(SoftwareBitmap bitmap, IList <PredictionModel> result)
{
WriteableBitmap newImage = new WriteableBitmap(bitmap.PixelWidth, bitmap.PixelHeight);
bitmap.CopyToBuffer(newImage.PixelBuffer);
for (int predictIdx = 0; predictIdx < result.Count; predictIdx++)
{
PredictionModel predictInfo = result[predictIdx];
newImage.DrawRectangle((int)predictInfo.BoundingBox.Left * bitmap.PixelWidth,
(int)predictInfo.BoundingBox.Top * bitmap.PixelHeight,
(int)predictInfo.BoundingBox.Width * bitmap.PixelWidth,
(int)predictInfo.BoundingBox.Height * bitmap.PixelHeight,
Colors.Red);
}
Windows.Storage.StorageFile testFile = await folder.CreateFileAsync("test.jpg", Windows.Storage.CreationCollisionOption.ReplaceExisting);
using (IRandomAccessStream stream = await testFile.OpenAsync(FileAccessMode.ReadWrite))
{
Guid BitmapEncoderGuid = BitmapEncoder.JpegEncoderId;
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoderGuid, stream);
Stream pixelStream = newImage.PixelBuffer.AsStream();
byte[] pixels = new byte[pixelStream.Length];
await pixelStream.ReadAsync(pixels, 0, pixels.Length);
encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore,
(uint)newImage.PixelWidth,
(uint)newImage.PixelHeight,
96.0,
96.0,
pixels);
await encoder.FlushAsync();
}
}
private async void selectPhoto(object sender, RoutedEventArgs e)
{
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail;
picker.SuggestedStartLocation =
Windows.Storage.Pickers.PickerLocationId.PicturesLibrary;
picker.FileTypeFilter.Add(".jpg");
picker.FileTypeFilter.Add(".jpeg");
picker.FileTypeFilter.Add(".png");
Windows.Storage.StorageFile file = await picker.PickSingleFileAsync();
if (file != null)
{
using (IRandomAccessStream fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read))
{
BitmapImage bitmapImage = new BitmapImage();
bitmapImage.DecodePixelWidth = 353;
await bitmapImage.SetSourceAsync(fileStream);
userFace.Source = bitmapImage;
var fileToSave = await ApplicationData.Current.TemporaryFolder.CreateFileAsync("temp.png", CreationCollisionOption.ReplaceExisting);
var stream = await file.OpenReadAsync();
var bytes = await Temp.GetBytesFromStream(stream);
await FileIO.WriteBytesAsync(fileToSave, bytes);
}
}
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail;
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary;
picker.FileTypeFilter.Add(".jpg");
picker.FileTypeFilter.Add(".jpeg");
picker.FileTypeFilter.Add(".png");
Windows.Storage.StorageFile file = await picker.PickSingleFileAsync();
if (file != null)
{
// Application now has read/write access to the picked file
this.textblock.Text = "Picked photo: " + file.Name;
var stream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read);
image.SetSource(stream);
imageView.Source = image;
}
else
{
this.textblock.Text = "Operation cancelled.";
}
}
async void PickFile(object sender, RoutedEventArgs e)
{
var currentState = Windows.UI.ViewManagement.ApplicationView.Value;
if (currentState == Windows.UI.ViewManagement.ApplicationViewState.Snapped && !Windows.UI.ViewManagement.ApplicationView.TryUnsnap())
{
TranscodeError("Cannot pick files while application is in snapped view");
}
else
{
Windows.Storage.Pickers.FileOpenPicker picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.VideosLibrary;
picker.FileTypeFilter.Add(".wmv");
picker.FileTypeFilter.Add(".mp4");
Windows.Storage.StorageFile file = await picker.PickSingleFileAsync();
if (file != null)
{
Windows.Storage.Streams.IRandomAccessStream stream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read);
_InputFile = file;
InputVideo.SetSource(stream, file.ContentType);
InputVideo.Play();
// Enable buttons
EnableButtons();
}
}
}
public async static Task<BitmapImage> GetImageAsync(StorageFile storageFile)
{
BitmapImage bitmapImage = new BitmapImage();
FileRandomAccessStream stream = (FileRandomAccessStream)await storageFile.OpenAsync(FileAccessMode.Read);
bitmapImage.SetSource(stream);
return bitmapImage;
}
private async void OnDeferredImageRequestedHandler(DataProviderRequest providerRequest, StorageFile imageFile)
{
// In this delegate we provide updated Bitmap data using delayed rendering.
if (imageFile != null)
{
// If the delegate is calling any asynchronous operations it needs to acquire the deferral first. This lets the
// system know that you are performing some operations that might take a little longer and that the call to
// SetData could happen after the delegate returns. Once you acquired the deferral object you must call Complete
// on it after your final call to SetData.
DataProviderDeferral deferral = providerRequest.GetDeferral();
InMemoryRandomAccessStream inMemoryStream = new InMemoryRandomAccessStream();
// Make sure to always call Complete when done with the deferral.
try
{
// Decode the image and re-encode it at 50% width and height.
IRandomAccessStream imageStream = await imageFile.OpenAsync(FileAccessMode.Read);
BitmapDecoder imageDecoder = await BitmapDecoder.CreateAsync(imageStream);
BitmapEncoder imageEncoder = await BitmapEncoder.CreateForTranscodingAsync(inMemoryStream, imageDecoder);
imageEncoder.BitmapTransform.ScaledWidth = (uint)(imageDecoder.OrientedPixelWidth * 0.5);
imageEncoder.BitmapTransform.ScaledHeight = (uint)(imageDecoder.OrientedPixelHeight * 0.5);
await imageEncoder.FlushAsync();
providerRequest.SetData(RandomAccessStreamReference.CreateFromStream(inMemoryStream));
}
finally
{
deferral.Complete();
}
}
}
private async void btnSeleccionarImagen_Click(object sender, RoutedEventArgs e)
{
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail;
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.Desktop;
picker.FileTypeFilter.Add(".png");
Windows.Storage.StorageFile file = await picker.PickSingleFileAsync();
if (file != null)
{
// Application now has read/write access to the picked file
URLImage = file.Name;
using (var randomAccessStream = await file.OpenAsync(FileAccessMode.Read))
{
var result = new BitmapImage();
await result.SetSourceAsync(randomAccessStream);
imgPueblo.Source = result;
}
}
else
{
}
}
protected GameViewModel()
: base()
{
CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
MediaPlayer = new MediaElement();
});
lock (locker)
{
if (StopwatchFile == null || AlarmFile == null)
{
LoadFileTask = Task.Run(async () =>
{
StorageFolder folder = await (await Package.Current.InstalledLocation.GetFolderAsync("Assets")).GetFolderAsync("Sounds");
StopwatchFile = await folder.GetFileAsync("Stopwatch.wav");
AlarmFile = await folder.GetFileAsync("Alarm.wav");
CheerFile = await folder.GetFileAsync("Cheer.wav");
AwwFile = await folder.GetFileAsync("Aww.wav");
VictoryFile = await folder.GetFileAsync("Victory.wav");
(await StopwatchFile.OpenAsync(FileAccessMode.Read)).AsStream().CopyTo(StopwatchStream);
(await AlarmFile.OpenAsync(FileAccessMode.Read)).AsStream().CopyTo(AlarmStream);
(await CheerFile.OpenAsync(FileAccessMode.Read)).AsStream().CopyTo(CheerStream);
(await AwwFile.OpenAsync(FileAccessMode.Read)).AsStream().CopyTo(AwwStream);
(await VictoryFile.OpenAsync(FileAccessMode.Read)).AsStream().CopyTo(VictoryStream);
});
}
}
}
private async Task<BitmapImage> LoadImage(StorageFile file)
{
var image = new BitmapImage();
FileRandomAccessStream stream = (FileRandomAccessStream)await file.OpenAsync(FileAccessMode.Read);
image.SetSource(stream);
return image;
}
private async void MenuFlyoutItem_Click_7(object sender, RoutedEventArgs e)
{
Windows.Storage.Pickers.FileOpenPicker open =
new Windows.Storage.Pickers.FileOpenPicker();
open.SuggestedStartLocation =
Windows.Storage.Pickers.PickerLocationId.DocumentsLibrary;
open.FileTypeFilter.Add(".rtf");
Windows.Storage.StorageFile file = await open.PickSingleFileAsync();
if (file != null)
{
try
{
Windows.Storage.Streams.IRandomAccessStream randAccStream =
await file.OpenAsync(Windows.Storage.FileAccessMode.Read);
flextextwrite.Document.LoadFromStream(Windows.UI.Text.TextSetOptions.FormatRtf, randAccStream);
}
catch (Exception)
{
ContentDialog errorDialog = new ContentDialog()
{
Title = "File open error",
Content = "Sorry, I couldn't open the file.",
PrimaryButtonText = "Ok"
};
await errorDialog.ShowAsync();
}
}
}
private async Task GetFileReference()
{
if (SaveSerialToggleButton.IsChecked.GetValueOrDefault())
{
try
{
file = await StorageApplicationPermissions.FutureAccessList.GetFileAsync("Default");
await file.OpenAsync(FileAccessMode.ReadWrite);
}
catch
{
}
if (file == null)
{
var savePicker = new Windows.Storage.Pickers.FileSavePicker();
savePicker.SuggestedStartLocation =
Windows.Storage.Pickers.PickerLocationId.DocumentsLibrary;
// Dropdown of file types the user can save the file as
savePicker.FileTypeChoices.Add("Plain Text", new List <string>()
{
".txt"
});
// Default file name if the user does not type one in or select a file to replace
savePicker.SuggestedFileName = "705SerialData";
file = await savePicker.PickSaveFileAsync();
StorageApplicationPermissions.FutureAccessList.AddOrReplace("Default", file);
}
}
}
private async void Open_Click(object sender, RoutedEventArgs e)
{
//文件选择器
FileOpenPicker openPicker = new FileOpenPicker();
//初始位置
openPicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
//添加文件类型
openPicker.FileTypeFilter.Add(".jpg");
openPicker.FileTypeFilter.Add(".jpeg");
openPicker.FileTypeFilter.Add(".png");
openPicker.FileTypeFilter.Add(".gif");
//选取单个文件
Windows.Storage.StorageFile file = await openPicker.PickSingleFileAsync();
if (file != null)
{
using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.Read))
{
var srcImage = new BitmapImage();
await srcImage.SetSourceAsync(stream);
Img.Source = srcImage;
}
}
}
private async Task<Uri> SaveToFile(StorageFile file)
{
Uri uri = null;
if (inkCanvas.InkPresenter.StrokeContainer.GetStrokes().Count > 0)
{
try
{
using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
await inkCanvas.InkPresenter.StrokeContainer.SaveAsync(stream);
uri = new Uri("ms-appdata:///local/" + file.Name);
}
}
catch (Exception ex)
{
if (Debugger.IsAttached)
{
Debugger.Break();
}
}
}
return uri;
}
private async void RenderInkImageAsync()
{
IReadOnlyList <InkStroke> currentStrokes = inkCanvas.InkPresenter.StrokeContainer.GetStrokes();
if (currentStrokes.Count > 0)
{
Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.TemporaryFolder;
Windows.Storage.StorageFile file = await storageFolder.CreateFileAsync($"{Guid.NewGuid()}.png", Windows.Storage.CreationCollisionOption.ReplaceExisting);
if (file != null)
{
Windows.Storage.CachedFileManager.DeferUpdates(file);
IRandomAccessStream stream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
using (IOutputStream outputStream = stream.GetOutputStreamAt(0))
{
await inkCanvas.InkPresenter.StrokeContainer.SaveAsync(outputStream);
await outputStream.FlushAsync();
}
stream.Dispose();
}
BitmapImage bm = new BitmapImage(new Uri($"ms-appdata:///temp/{file.Name}"));
App.ViewModel.SelectedDocument.AnnotationImage = bm;
}
Frame.GoBack();
}
public async System.Threading.Tasks.Task saveImageAsync()
{
Stream pixelStream = this.bitmap1.PixelBuffer.AsStream();
byte[] pixels = new byte[pixelStream.Length];
await pixelStream.ReadAsync(pixels, 0, pixels.Length);
var savePicker = new Windows.Storage.Pickers.FileSavePicker();
savePicker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.DocumentsLibrary;
// dropdown menu of file types the user can save the file as
savePicker.FileTypeChoices.Add("PNG", new List <string>()
{
".png"
});
// default file name if the user does not type one in or select a file to replace
savePicker.SuggestedFileName = "IR_Capture";
Windows.Storage.StorageFile file = await savePicker.PickSaveFileAsync();
if (file != null)
{
IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.ReadWrite);
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, stream);
encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, (uint)bitmap1.PixelWidth, (uint)bitmap1.PixelHeight, 96.0, 96.0, pixels);
await encoder.FlushAsync();
}
}
private async void UploadImage_OnClick(object sender, TappedRoutedEventArgs e)
{
// Opening the file explorer
var picker =
new Windows.Storage.Pickers.FileOpenPicker
{
ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail,
SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary
};
picker.FileTypeFilter.Add(".jpg");
picker.FileTypeFilter.Add(".jpeg");
picker.FileTypeFilter.Add(".png");
Windows.Storage.StorageFile file = await picker.PickSingleFileAsync();
if (file != null)
{
// Application now has read/write access to the picked file
using (var fileStream = await file.OpenAsync(FileAccessMode.Read))
{
await ImgurApi.UploadImage(fileStream, _user);
}
}
else
{
// cancell action
}
}
/// <summary>
/// 通过FilePicker获取富文本流（弹出框选文件）
/// </summary>
/// <returns>富文本流</returns>
public async Task <IRandomAccessStream> GetRandomAccessStream()
{
Windows.Storage.Pickers.FileOpenPicker open =
new Windows.Storage.Pickers.FileOpenPicker();
open.SuggestedStartLocation =
Windows.Storage.Pickers.PickerLocationId.DocumentsLibrary;
open.FileTypeFilter.Add(".rtf");
Windows.Storage.StorageFile file = await open.PickSingleFileAsync();
if (file != null)
{
try
{
Windows.Storage.Streams.IRandomAccessStream randAccStream =
await file.OpenAsync(Windows.Storage.FileAccessMode.Read);
// Load the file into the Document property of the RichEditBox.
return(randAccStream);
}
catch (Exception)
{
ContentDialog errorDialog = new ContentDialog()
{
Title = "File open error",
Content = "Sorry, I couldn't open the file.",
PrimaryButtonText = "Ok"
};
await errorDialog.ShowAsync();
}
}
return(null);
}
// Import board from GIF
private async void importBoard(object sender, RoutedEventArgs e)
{
// Let users choose their ink file using a file picker.
// Initialize the picker.
Windows.Storage.Pickers.FileOpenPicker openPicker =
new Windows.Storage.Pickers.FileOpenPicker();
openPicker.SuggestedStartLocation =
Windows.Storage.Pickers.PickerLocationId.DocumentsLibrary;
openPicker.FileTypeFilter.Add(".gif");
// Show the file picker.
Windows.Storage.StorageFile file = await openPicker.PickSingleFileAsync();
// User selects a file and picker returns a reference to the selected file.
if (file != null)
{
// Open a file stream for reading.
IRandomAccessStream stream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read);
// Read from file.
using (var inputStream = stream.GetInputStreamAt(0))
{
await inkCanvas.InkPresenter.StrokeContainer.LoadAsync(inputStream);
}
stream.Dispose();
}
// User selects Cancel and picker returns null.
else
{
// Operation cancelled.
}
}
private async void buttonSelectSong_Click(object sender, RoutedEventArgs e)
{
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.List;
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.MusicLibrary;
picker.FileTypeFilter.Add(".mp3");
picker.FileTypeFilter.Add(".wav");
selectedSongFile = await picker.PickSingleFileAsync();
if (selectedSongFile != null)
{
// Application now has read/write access to the picked file
textBoxSelectedSong.Text = selectedSongFile.Path;
//String path = "C:\\Users\\Venaca\\Music\\Písničky všechny\\Tancování\\10 letkiss---Letkiss.mp3";
// Windows.Storage.StorageFile selectedSongFile = StorageFile.GetFileFromPathAsync(path).GetResults();
var stream = await selectedSongFile.OpenAsync(Windows.Storage.FileAccessMode.Read);
player.SetSource(stream, "");
}
else
{
textBoxSelectedSong.Text = "";
}
}
private async void BtnOpen_Click(object sender, RoutedEventArgs e)
{
InkStrokeContainer container = new InkStrokeContainer();
Windows.Storage.Pickers.FileOpenPicker openPicker = new Windows.Storage.Pickers.FileOpenPicker();
openPicker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.DocumentsLibrary;
openPicker.FileTypeFilter.Add(".gif");
Windows.Storage.StorageFile file = await openPicker.PickSingleFileAsync();
if (file != null)
{
IRandomAccessStream stream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read);
using (var inputStream = stream.GetInputStreamAt(0))
{
await container.LoadAsync(inputStream);
}
stream.Dispose();
_inkStrokes.Clear();
_inkStrokes.Add(container);
DrawingCanvas.Invalidate();
}
else
{
}
}
private async void seleccionarImagen(object sender, RoutedEventArgs e)
{
FileOpenPicker picker = new FileOpenPicker();
picker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
picker.FileTypeFilter.Add(".png");
file = await picker.PickSingleFileAsync();
BitmapImage image = new BitmapImage();
try
{
using (var stream = await file.OpenAsync(FileAccessMode.Read))
{
await image.SetSourceAsync(stream);
}
ImageBrush brush = new ImageBrush();
brush.Stretch = Stretch.UniformToFill;
brush.ImageSource = image;
imagen.Fill = brush;
}
catch (Exception exception)
{
}
}
public static async Task<Color> GetDominantColorFromFile(StorageFile file)
{
//get the file
using (var stream = await file.OpenAsync(FileAccessMode.Read))
{
//Create a decoder for the image
var decoder = await BitmapDecoder.CreateAsync(stream);
//Create a transform to get a 1x1 image
var myTransform = new BitmapTransform { ScaledHeight = 1, ScaledWidth = 1 };
//Get the pixel provider
var pixels = await decoder.GetPixelDataAsync(
BitmapPixelFormat.Rgba8,
BitmapAlphaMode.Ignore,
myTransform,
ExifOrientationMode.IgnoreExifOrientation,
ColorManagementMode.DoNotColorManage);
//Get the bytes of the 1x1 scaled image
var bytes = pixels.DetachPixelData();
//read the color
var myDominantColor = Color.FromArgb(255, bytes[0], bytes[1], bytes[2]);
return myDominantColor;
}
}
public async void PrintPDF(Memo memo)
{
Reports = new Reports(memo);
//var stream = new InMemoryRandomAccessStream();
//FileSavePicker fileSavePicker = new FileSavePicker();
WriterFormat format = WriterFormat.PDF;
//fileSavePicker.SuggestedFileName = "ExportReport";
//var savedItem = await fileSavePicker.PickSaveFileAsync();
//if (savedItem != null)
//
Windows.Storage.StorageFolder storageFolder =
Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile savedItem =
await storageFolder.CreateFileAsync("sample.pdf",
Windows.Storage.CreationCollisionOption.ReplaceExisting);
//var savedItem = await FileSavePicker.PickSaveFileAsync();
MemoryStream exportFileStream = new MemoryStream();
Assembly assembly = typeof(HomePage).GetTypeInfo().Assembly;
// Ensure the report loaction and application name.
Stream reportStream = assembly.GetManifestResourceStream("UwpApp.Report.Inv.rdlc");
BoldReports.UI.Xaml.ReportDataSourceCollection datas = new BoldReports.UI.Xaml.ReportDataSourceCollection();
datas.Add(new BoldReports.UI.Xaml.ReportDataSource {
Name = "PatientInfo", Value = Reports.LoadReport()
});
datas.Add(new BoldReports.UI.Xaml.ReportDataSource {
Name = "MemoDetails", Value = Reports.loadmemodetail()
});
ReportWriter writer = new ReportWriter(reportStream, datas);
writer.ExportMode = ExportMode.Local;
await writer.SaveASync(exportFileStream, format);
try
{
using (IRandomAccessStream stream = await savedItem.OpenAsync(FileAccessMode.ReadWrite))
{
// Write compressed data from memory to file
using (Stream outstream = stream.AsStreamForWrite())
{
byte[] buffer = exportFileStream.ToArray();
outstream.Write(buffer, 0, buffer.Length);
outstream.Flush();
}
}
exportFileStream.Dispose();
}
catch { }
}
/// <summary>
/// Metode for å gjøre om fil til bilde.
/// </summary>
private async Task<BitmapImage> GetBitmapImageAsync(StorageFile storageFile)
{
var bitmapImage = new BitmapImage();
IAsyncOperation<IRandomAccessStream> operation = storageFile.OpenAsync(FileAccessMode.Read);
IRandomAccessStream stream = await operation;
bitmapImage.SetSource(stream);
return bitmapImage;
}
public static async Task<string> ToBase64(StorageFile bitmap)
{
var stream = await bitmap.OpenAsync(FileAccessMode.Read);
var decoder = await BitmapDecoder.CreateAsync(stream);
var pixels = await decoder.GetPixelDataAsync();
var bytes = pixels.DetachPixelData();
return await ToBase64(bytes, decoder.PixelWidth, decoder.PixelHeight, decoder.DpiX, decoder.DpiY);
}
public static async Task<string> EncodeFromStorageFile(StorageFile bitmap)
{
var stream = await bitmap.OpenAsync(Windows.Storage.FileAccessMode.Read);
var decoder = await BitmapDecoder.CreateAsync(stream);
var pixels = await decoder.GetPixelDataAsync();
var bytes = pixels.DetachPixelData();
return await EncodeFromByte(bytes, (uint)decoder.PixelWidth, (uint)decoder.PixelHeight, decoder.DpiX, decoder.DpiY);
}
static async public Task<BitmapImage> GetImage(StorageFile file)
{
IRandomAccessStream photoStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read);
BitmapImage bmpimg = new BitmapImage();
bmpimg.SetSource(photoStream);
return bmpimg;
}
public async void UploadFileAsync(StorageFile file)
{
var fileContent = await file.OpenAsync(FileAccessMode.Read);
HttpStreamContent fileStream = new HttpStreamContent(fileContent);
HttpMultipartFormDataContent formData = new HttpMultipartFormDataContent { { fileStream, "file", file.Path } };
var asyncOperation = BoxHttpClient.PostAsync(new Uri(BoxUploadUrl), formData);
int index = UploadFileList.AddEntry(file, DateTime.Now, asyncOperation);
UploadFileList[index].StartUpload();
}
public async Task<WriteableBitmap> RetrieveAndPutBitmapAsync(StorageFile file)
{
IRandomAccessStream contents = await file.OpenAsync(FileAccessMode.Read);
WriteableBitmap bitmap = new WriteableBitmap(100, 100);
bitmap.SetSource(contents);
_cache.Add(new BitmapCacheItem() { StorageFile = file, Bitmap = bitmap });
Debug.WriteLine("Caching bitmap for file: " + file.Path + "::" + file.Name);
return bitmap;
}
public async Task TakeScreenshotAsync(FrameworkElement element, StorageFile file)
{
CachedFileManager.DeferUpdates(file);
using (var stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
await CaptureToStreamAsync(element, stream, BitmapEncoder.PngEncoderId);
}
await CachedFileManager.CompleteUpdatesAsync(file);
}
public IAsyncInfo GenerateGif(StorageFile outputFile, int delay, bool repeat, List<byte[]> sourceBytes)
{
return AsyncInfo.Run(async ctx =>
{
var outStream = await outputFile.OpenAsync(FileAccessMode.ReadWrite);
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.GifEncoderId, outStream);
if (repeat) // set repeat property
{
var containerProperties = new BitmapPropertySet
{
{ "/appext/Application", new BitmapTypedValue(Encoding.UTF8.GetBytes("NETSCAPE2.0"), PropertyType.UInt8Array) },
{ "/appext/Data", new BitmapTypedValue(new byte[] { 3, 1, 0, 0, 0 }, PropertyType.UInt8Array) },
};
await encoder.BitmapContainerProperties.SetPropertiesAsync(containerProperties);
}
try
{
for (int i = 0; i < sourceBytes.Count; i++)
{
using (MemoryRandomAccessStream frameStream = new MemoryRandomAccessStream(sourceBytes[i]))
{
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(frameStream);
PixelDataProvider pixels = await decoder.GetPixelDataAsync();
encoder.SetPixelData(decoder.BitmapPixelFormat, BitmapAlphaMode.Ignore,
decoder.OrientedPixelWidth, decoder.OrientedPixelHeight,
decoder.DpiX, decoder.DpiY,
pixels.DetachPixelData());
if (i == 0)
{
var properties = new BitmapPropertySet{ { "/grctlext/Delay", new BitmapTypedValue(delay / 10, PropertyType.UInt16) } };
await encoder.BitmapProperties.SetPropertiesAsync(properties);
}
if (i < sourceBytes.Count - 1)
await encoder.GoToNextFrameAsync();
}
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("exception caught: " + ex.ToString());
// throw ex;
}
await encoder.FlushAsync();
outStream.Dispose();
});
}
public async Task<byte[]> GetPhotoBytesAsync(StorageFile file)
{
IRandomAccessStream fileStream = await file.OpenAsync(FileAccessMode.Read);
var reader = new Windows.Storage.Streams.DataReader(fileStream.GetInputStreamAt(0));
await reader.LoadAsync((uint)fileStream.Size);
byte[] pixels = new byte[fileStream.Size];
reader.ReadBytes(pixels);
return pixels;
}
public async Task<Byte[]> ImageFileToByteArray(StorageFile file)
{
IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.Read);
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
PixelDataProvider pixelData = await decoder.GetPixelDataAsync();
return pixelData.DetachPixelData();
}
private static async Task<BitmapImage> CarregarImagem(StorageFile arquivo)
{
BitmapImage bitmapImage = new BitmapImage();
FileRandomAccessStream stream = (FileRandomAccessStream)await arquivo.OpenAsync(FileAccessMode.Read);
bitmapImage.SetSource(stream);
return bitmapImage;
}
private async void LoadThumbnail(StorageFile file)
{
var image = new BitmapImage();
image.DecodePixelHeight = 72;
using (var stream = (FileRandomAccessStream)await file.OpenAsync(FileAccessMode.Read))
{
await image.SetSourceAsync(stream);
}
Image = image;
}
private async Task<uint> OpenFile(string fileName)
{
StorageFolder myStorageFolder = KnownFolders.DocumentsLibrary;
myFile = await myStorageFolder.GetFileAsync("ECHelper Files\\" + fileName+".ech");
readStream = await myFile.OpenAsync(FileAccessMode.Read);
fileReader = new DataReader(readStream);
count = await fileReader.LoadAsync((uint)readStream.Size);
data = new byte[count];
fileReader.ReadBytes(data);
return count;
}
public static async Task<WriteableBitmap> GetPictureAsync(StorageFile ImageFile)
{
using (IRandomAccessStream stream = await ImageFile.OpenAsync(FileAccessMode.Read))
{
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
WriteableBitmap bmp = new WriteableBitmap((int)decoder.PixelWidth, (int)decoder.PixelHeight);
await bmp.SetSourceAsync(stream);
return bmp;
}
}
private async Task LoadImage(StorageFile file)
{
ImageProperties imgProp = await file.Properties.GetImagePropertiesAsync();
using (var imgStream = await file.OpenAsync(FileAccessMode.Read))
{
bitmap = new WriteableBitmap((int)imgProp.Width, (int)imgProp.Height);
bitmap.SetSource(imgStream);
PreviewImage.Source = bitmap;
}
}
private async Task<BitmapImage> LoadImage(StorageFile file)
{
BitmapImage bitmapImage = new BitmapImage();
// Create a stream to display the file
FileRandomAccessStream stream = (FileRandomAccessStream)await file.OpenAsync(FileAccessMode.Read);
// Set the stream
bitmapImage.SetSource(stream);
return bitmapImage;
}
public static async Task<WriteableBitmap> LoadImage(StorageFile file)
{
ImageProperties imgProp = await file.Properties.GetImagePropertiesAsync();
using (var imgStream = await file.OpenAsync(FileAccessMode.Read))
{
WriteableBitmap writeablebitmap = new WriteableBitmap((int)imgProp.Width, (int)imgProp.Height);
writeablebitmap.SetSource(imgStream);
return writeablebitmap;
}
}
public static async Task<SoftwareBitmap> StorageFileToSoftwareBitmap(StorageFile file)
{
if (file == null)
return null;
using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.Read))
{
// Create the decoder from the stream
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
// Get the SoftwareBitmap representation of the file
SoftwareBitmap softwareBitmap = await decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
return softwareBitmap;
}
}
