private static void waitAndProcessImage(string[] fileTypes, string[] dataPathPatterns, int maxWidth, int maxHeight, StreamLoadedCallbackMethod streamLoadedCallback)
{
// wait for event
while (true)
{
IntPtr _event = IntPtr.Zero;
Common.bps_get_event(ref _event, -1); // wait here for next event
if (_event != IntPtr.Zero)
{
if (Common.bps_event_get_code(_event) == NAVIGATOR_CHILD_CARD_CLOSED)
{
IntPtr reasonPtr = Common.navigator_event_get_card_closed_reason(_event);
string reason = Marshal.PtrToStringAnsi(reasonPtr);
Debug.Log("reason: " + reason);
if (reason == "save") //save - cancel
{
IntPtr dataPathPtr = Common.navigator_event_get_card_closed_data(_event);
string dataPath = Marshal.PtrToStringAnsi(dataPathPtr);
Debug.Log("Loading file from dataPath: " + dataPath);
try
{
System.Text.RegularExpressions.MatchCollection matches = null;
foreach (var pattern in dataPathPatterns)
{
matches = System.Text.RegularExpressions.Regex.Matches(dataPath, pattern);
if (matches.Count != 0)
{
break;
}
}
if (matches != null)
{
foreach (System.Text.RegularExpressions.Match match in matches)
{
if (match.Groups.Count == 3)
{
string path = match.Groups[1].Value;
string fileName = match.Groups[2].Value;
// check for valid file type
bool pass = false;
foreach (var type in fileTypes)
{
if (Path.GetExtension(fileName) == type)
{
pass = true;
break;
}
}
if (!pass)
{
throw new Exception("Invalid file ext.");
}
// load file
MemoryStream stream = null;
using (var file = new FileStream(path + fileName, FileMode.Open, FileAccess.Read))
{
if (maxWidth != 0 && maxHeight != 0)
{
ImageTools.IO.IImageDecoder decoder = null;
switch (Path.GetExtension(fileName).ToLower())
{
case ".jpg": decoder = new ImageTools.IO.Jpeg.JpegDecoder(); break;
case ".jpeg": decoder = new ImageTools.IO.Jpeg.JpegDecoder(); break;
case ".png": decoder = new ImageTools.IO.Png.PngDecoder(); break;
default:
Debug.LogError("Unsuported file ext type: " + Path.GetExtension(fileName));
streamLoadedCallback(null, false);
return;
}
var image = new ImageTools.ExtendedImage();
decoder.Decode(image, file);
var newSize = MathUtilities.FitInViewIfLarger(image.PixelWidth, image.PixelHeight, maxWidth, maxHeight);
var newImage = ImageTools.ExtendedImage.Resize(image, (int)newSize.x, (int)newSize.y, new ImageTools.Filtering.NearestNeighborResizer());
var encoder = new ImageTools.IO.Jpeg.JpegEncoder();
stream = new MemoryStream();
encoder.Encode(newImage, stream);
stream.Position = 0;
/*unsafe
* {
* IntPtr ilib = IntPtr.Zero;
* if (img_lib_attach(&ilib) != 0)
* {
* Debug.LogError("Failed: img_lib_attach");
* streamLoadedCallback(null, false);
* return;
* }
*
* img_t image = new img_t();
* image.flags = 0x00000002;
* image.format = 32 | 0x00000100 | 0x00001000;
* img_decode_callouts_t callouts = new img_decode_callouts_t();
* if (img_load_file(ilib, "file://"+path+fileName, &callouts, &image) != 0)
* {
* img_t newImage = new img_t();
* if (img_resize_fs(&image, &newImage) != 0)
* {
* Debug.LogError("Failed: img_resize_fs");
* streamLoadedCallback(null, false);
* return;
* }
*
* Debug.Log("WIDTH: " + image.w);
* Debug.Log("HEIGHT: " + image.h);
* streamLoadedCallback(null, false);
* return;
* //byte* data = (byte*)newImage.data.ToPointer();
* //byte[] managedData = new byte[newImage.stride];
*
* //stream = new MemoryStream();
* }
* else
* {
* Debug.LogError("Failed to load image file: " + path + fileName);
* streamLoadedCallback(null, false);
* return;
* }
*
* img_lib_detach(ilib);
* }*/
}
else
{
var data = new byte[file.Length];
file.Read(data, 0, data.Length);
stream = new MemoryStream(data);
stream.Position = 0;
}
}
streamLoadedCallback(stream, true);
return;
}
else
{
throw new Exception("Invalid dataPath.");
}
}
}
}
catch (Exception e)
{
Debug.LogError(e.Message);
}
streamLoadedCallback(null, false);
}
else
{
streamLoadedCallback(null, false);
}
break;
}
}
}
}
public override void LoadFileDialog(FolderLocations folderLocation, int maxWidth, int maxHeight, int x, int y, int width, int height, string[] fileTypes, StreamLoadedCallbackMethod streamLoadedCallback)
{
if (streamLoadedCallback == null)
{
return;
}
// open native dlg
var file = new OPENFILENAME();
file.lStructSize = (uint)Marshal.SizeOf(typeof(OPENFILENAME));
file.hwndOwner = IntPtr.Zero;
file.lpstrDefExt = IntPtr.Zero;
file.lpstrFile = Marshal.AllocHGlobal((int)MAX_PATH);
unsafe { ((byte *)file.lpstrFile.ToPointer())[0] = 0; }
file.nMaxFile = MAX_PATH;
file.lpstrFilter = generateFilterValue(fileTypes);
file.nFilterIndex = 0;
file.lpstrInitialDir = Marshal.StringToHGlobalUni(Application.dataPath);
file.lpstrTitle = Marshal.StringToHGlobalUni("Load file");
file.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST | OFN_NOCHANGEDIR;
GetOpenFileName(ref file);
// get native dlg result
string filename = null;
if (file.lpstrFile != IntPtr.Zero)
{
filename = Marshal.PtrToStringUni(file.lpstrFile);
Debug.Log("Loading file: " + filename);
}
Marshal.FreeHGlobal(file.lpstrFile);
Marshal.FreeHGlobal(file.lpstrInitialDir);
Marshal.FreeHGlobal(file.lpstrTitle);
Marshal.FreeHGlobal(file.lpstrFilter);
// open file
if (!string.IsNullOrEmpty(filename))
{
if (maxWidth == 0 || maxHeight == 0 || folderLocation != FolderLocations.Pictures)
{
streamLoadedCallback(new FileStream(filename, FileMode.Open, FileAccess.Read), true);
}
else
{
var newStream = new MemoryStream();
try
{
using (var stream = new FileStream(filename, FileMode.Open, FileAccess.Read))
{
ImageTools.IO.IImageDecoder decoder = null;
switch (Path.GetExtension(filename).ToLower())
{
case ".jpg": decoder = new ImageTools.IO.Jpeg.JpegDecoder(); break;
case ".jpeg": decoder = new ImageTools.IO.Jpeg.JpegDecoder(); break;
case ".png": decoder = new ImageTools.IO.Png.PngDecoder(); break;
default:
Debug.LogError("Unsuported file ext type: " + Path.GetExtension(filename));
streamLoadedCallback(null, false);
return;
}
var image = new ExtendedImage();
decoder.Decode(image, stream);
var newSize = Reign.MathUtilities.FitInViewIfLarger(image.PixelWidth, image.PixelHeight, maxWidth, maxHeight);
var newImage = ExtendedImage.Resize(image, (int)newSize.x, (int)newSize.y, new NearestNeighborResizer());
var encoder = new PngEncoder();
encoder.Encode(newImage, newStream);
newStream.Position = 0;
}
}
catch (Exception e)
{
newStream.Dispose();
newStream = null;
Debug.LogError(e.Message);
}
finally
{
streamLoadedCallback(newStream, true);
}
}
}
else
{
streamLoadedCallback(null, false);
}
}