public override bool ShowDialog(out string log)
{
if (Thread.CurrentThread.GetApartmentState() != ApartmentState.STA)
{
throw new InvalidOperationException("Main関数にSTAThreadAttributeが設定されていることを確認してください");
}
var path = Engine.Tool.SaveDialog(Filter ?? string.Empty, Directory.Exists(InitialDirectory) ? InitialDirectory : string.Empty);
if (string.IsNullOrEmpty(path))
{
log = null;
return(false);
}
if (AddExtension && !string.IsNullOrEmpty(DefaultExtension) && path.IndexOfAny(Path.GetInvalidPathChars()) < 0 && !string.IsNullOrWhiteSpace(path))
{
var ex = $".{DefaultExtension.TrimStart('.')}";
if (Path.GetExtension(path).Length == 0)
{
path += ex;
}
}
if (CheckFileExists && !Engine.File.Exists(path))
{
log = $"File does not exists\nPath: {path}";
return(false);
}
if (CheckPathExists && !CheckFilePath(path, out log))
{
return(false);
}
log = null;
FileName = path;
return(true);
}
private VirtualPathStatus ExistsPath(string urlPath, ref string localPath)
{
// check if the path is just a directoy and return
if (UseDirectoryBrowser && Directory.Exists(localPath))
{
return(VirtualPathStatus.Directory);
}
if (string.IsNullOrWhiteSpace(DefaultExtension) == false && DefaultExtension.StartsWith(".") &&
File.Exists(localPath) == false)
{
localPath += DefaultExtension;
}
if (File.Exists(localPath))
{
return(VirtualPathStatus.File);
}
if (File.Exists(Path.Combine(localPath, DefaultDocument)))
{
localPath = Path.Combine(localPath, DefaultDocument);
}
else
{
// Try to fallback to root
var rootLocalPath = Path.Combine(FileSystemPath, urlPath);
if (UseDirectoryBrowser && Directory.Exists(rootLocalPath))
{
localPath = rootLocalPath;
return(VirtualPathStatus.Directory);
}
if (File.Exists(rootLocalPath))
{
localPath = rootLocalPath;
}
else if (File.Exists(Path.Combine(rootLocalPath, DefaultDocument)))
{
localPath = Path.Combine(rootLocalPath, DefaultDocument);
}
else
{
return(VirtualPathStatus.Invalid);
}
}
return(VirtualPathStatus.File);
}
internal bool ExistsLocalPath(string urlPath, ref string localPath)
{
if (_validPaths.TryGetValue(localPath, out var tempPath))
{
localPath = tempPath;
return(true);
}
var originalPath = localPath;
if (string.IsNullOrWhiteSpace(DefaultExtension) == false && DefaultExtension.StartsWith(".") &&
File.Exists(localPath) == false)
{
localPath += DefaultExtension;
}
if (File.Exists(localPath))
{
_validPaths.TryAdd(originalPath, localPath);
return(true);
}
if (Directory.Exists(localPath) && File.Exists(Path.Combine(localPath, DefaultDocument)))
{
localPath = Path.Combine(localPath, DefaultDocument);
}
else
{
// Try to fallback to root
var rootLocalPath = Path.Combine(FileSystemPath, urlPath);
if (File.Exists(rootLocalPath))
{
localPath = rootLocalPath;
}
else if (Directory.Exists(rootLocalPath) && File.Exists(Path.Combine(rootLocalPath, DefaultDocument)))
{
localPath = Path.Combine(rootLocalPath, DefaultDocument);
}
else
{
return(false);
}
}
_validPaths.TryAdd(originalPath, localPath);
return(true);
}
private bool ExistsLocalPath(string urlPath, ref string localPath)
{
if (string.IsNullOrWhiteSpace(DefaultExtension) == false && DefaultExtension.StartsWith(".") &&
File.Exists(localPath) == false)
{
localPath += DefaultExtension;
}
if (File.Exists(localPath))
{
return(true);
}
if (Directory.Exists(localPath) && File.Exists(Path.Combine(localPath, DefaultDocument)))
{
localPath = Path.Combine(localPath, DefaultDocument);
}
else
{
// Try to fallback to root
var rootLocalPath = Path.Combine(FileSystemPath, urlPath);
if (File.Exists(rootLocalPath))
{
localPath = rootLocalPath;
}
else if (Directory.Exists(rootLocalPath) && File.Exists(Path.Combine(rootLocalPath, DefaultDocument)))
{
localPath = Path.Combine(rootLocalPath, DefaultDocument);
}
else
{
return(false);
}
}
return(true);
}
public override bool ShowDialog(out string log)
{
if (Thread.CurrentThread.GetApartmentState() != ApartmentState.STA)
{
throw new InvalidOperationException("Main関数にSTAThreadAttributeが設定されていることを確認してください");
}
if (MultiSelect)
{
var path = Engine.Tool.OpenDialogMultiple(Filter ?? string.Empty, Directory.Exists(InitialDirectory) ? InitialDirectory : string.Empty);
if (string.IsNullOrEmpty(path))
{
log = null;
return(false);
}
var array = path.Split(',');
if (AddExtension && !string.IsNullOrEmpty(DefaultExtension))
{
for (int i = 0; i < array.Length; i++)
{
if (array[i].IndexOfAny(Path.GetInvalidPathChars()) < 0 && !string.IsNullOrWhiteSpace(array[i]))
{
var ex = $".{DefaultExtension.TrimStart('.')}";
if (Path.GetExtension(array[i]).Length == 0)
{
array[i] += ex;
}
}
}
}
if (CheckFileExists)
{
for (int i = 0; i < array.Length; i++)
{
if (!Engine.File.Exists(array[i]))
{
log = $"File does not exists\nPath: {array[i]}";
return(false);
}
}
}
if (CheckPathExists)
{
for (int i = 0; i < array.Length; i++)
{
if (!CheckFilePath(array[i], out log))
{
return(false);
}
}
}
log = null;
FileName = path;
FileNames = array;
return(true);
}
else
{
var path = Engine.Tool.OpenDialog(Filter ?? string.Empty, Directory.Exists(InitialDirectory) ? InitialDirectory : string.Empty);
if (string.IsNullOrEmpty(path))
{
log = null;
return(false);
}
if (AddExtension && !string.IsNullOrEmpty(DefaultExtension) && path.IndexOfAny(Path.GetInvalidPathChars()) < 0 && !string.IsNullOrWhiteSpace(path))
{
var ex = $".{DefaultExtension.TrimStart('.')}";
if (Path.GetExtension(path).Length == 0)
{
path += ex;
}
}
if (CheckFileExists && !Engine.File.Exists(path))
{
log = $"File does not exists\nPath: {path}";
return(false);
}
if (CheckPathExists && !CheckFilePath(path, out log))
{
return(false);
}
log = null;
FileName = path;
FileNames = new[] { path };
return(true);
}
}
private bool HandleGet(HttpListenerContext context, WebServer server, bool sendBuffer = true)
{
var urlPath = context.Request.Url.LocalPath.Replace('/', Path.DirectorySeparatorChar);
// adjust the path to see if we've got a default document
if (urlPath.Last() == Path.DirectorySeparatorChar)
{
urlPath = urlPath + DefaultDocument;
}
urlPath = urlPath.TrimStart(new char[] { Path.DirectorySeparatorChar });
var localPath = Path.Combine(FileSystemPath, urlPath);
var eTagValid = false;
byte[] buffer = null;
var fileDate = DateTime.Today;
var partialHeader = context.RequestHeader(Constants.HeaderRange);
var usingPartial = String.IsNullOrWhiteSpace(partialHeader) == false && partialHeader.StartsWith("bytes=");
if (string.IsNullOrWhiteSpace(DefaultExtension) == false && DefaultExtension.StartsWith(".") &&
File.Exists(localPath) == false)
{
var newPath = localPath + DefaultExtension;
if (File.Exists(newPath))
{
localPath = newPath;
}
}
if (File.Exists(localPath) == false)
{
return(false);
}
if (usingPartial == false)
{
fileDate = File.GetLastWriteTime(localPath);
var requestHash = context.RequestHeader(Constants.HeaderIfNotMatch);
if (RamCache.ContainsKey(localPath) && RamCache[localPath].LastModified == fileDate)
{
server.Log.DebugFormat("RAM Cache: {0}", localPath);
var currentHash = Extensions.ComputeMd5Hash(RamCache[localPath].Buffer) + '-' + fileDate.Ticks;
if (String.IsNullOrWhiteSpace(requestHash) || requestHash != currentHash)
{
buffer = RamCache[localPath].Buffer;
context.Response.AddHeader(Constants.HeaderETag, currentHash);
}
else
{
eTagValid = true;
}
}
else
{
server.Log.DebugFormat("File System: {0}", localPath);
if (sendBuffer)
{
buffer = File.ReadAllBytes(localPath);
var currentHash = Extensions.ComputeMd5Hash(buffer) + '-' + fileDate.Ticks;
if (String.IsNullOrWhiteSpace(requestHash) || requestHash != currentHash)
{
if (UseRamCache && buffer.Length <= MaxRamCacheFileSize)
{
RamCache[localPath] = new RamCacheEntry()
{
LastModified = fileDate, Buffer = buffer
};
}
context.Response.AddHeader(Constants.HeaderETag, currentHash);
}
else
{
eTagValid = true;
}
}
}
}
// check to see if the file was modified or etag is the same
var utcFileDateString = fileDate.ToUniversalTime()
.ToString(Constants.BrowserTimeFormat, CultureInfo.InvariantCulture);
if (usingPartial == false &&
(eTagValid || context.RequestHeader(Constants.HeaderIfModifiedSince).Equals(utcFileDateString)))
{
context.Response.AddHeader(Constants.HeaderCacheControl, "private");
context.Response.AddHeader(Constants.HeaderPragma, string.Empty);
context.Response.AddHeader(Constants.HeaderExpires, string.Empty);
context.Response.ContentType = string.Empty;
context.Response.StatusCode = 304;
}
else
{
var extension = Path.GetExtension(localPath).ToLowerInvariant();
if (MimeTypes.ContainsKey(extension))
{
context.Response.ContentType = MimeTypes[extension];
}
context.Response.AddHeader(Constants.HeaderCacheControl, "private");
context.Response.AddHeader(Constants.HeaderPragma, string.Empty);
context.Response.AddHeader(Constants.HeaderExpires, string.Empty);
context.Response.AddHeader(Constants.HeaderLastModified, utcFileDateString);
context.Response.AddHeader(Constants.HeaderAcceptRanges, "bytes");
if (sendBuffer)
{
var lrange = 0;
var urange = 0;
var size = (long)0;
var isPartial = false;
var fileSize = new FileInfo(localPath).Length;
if (usingPartial)
{
var range = partialHeader.Replace("bytes=", "").Split('-');
if (range.Length == 2 && int.TryParse(range[0], out lrange) &&
int.TryParse(range[1], out urange))
{
isPartial = true;
}
if ((range.Length == 2 && int.TryParse(range[0], out lrange) &&
string.IsNullOrWhiteSpace(range[1])) ||
(range.Length == 1 && int.TryParse(range[0], out lrange)))
{
urange = (int)fileSize - 1;
isPartial = true;
}
if (range.Length == 2 && string.IsNullOrWhiteSpace(range[0]) &&
int.TryParse(range[1], out urange))
{
lrange = (int)fileSize - urange;
urange = (int)fileSize - 1;
isPartial = true;
}
}
if (isPartial)
{
if (urange > fileSize)
{
context.Response.StatusCode = 416;
context.Response.AddHeader(Constants.HeaderContentRanges,
string.Format("bytes */{0}", fileSize));
return(true);
}
size = (urange - lrange) + 1;
context.Response.AddHeader(Constants.HeaderContentRanges,
string.Format("bytes {0}-{1}/{2}", lrange, urange, fileSize));
context.Response.StatusCode = 206;
server.Log.DebugFormat("Opening stream {0} bytes {1}-{2} size {3}", localPath, lrange, urange,
size);
buffer = new byte[size];
// Open FileStream with FileShare
using (var fs = new FileStream(localPath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
if (lrange + size > fs.Length)
{
size = fs.Length - lrange;
}
fs.Seek(lrange, SeekOrigin.Begin);
fs.Read(buffer, 0, (int)size);
fs.Close();
}
// Reset lower range
lrange = 0;
}
else
{
size = buffer.LongLength;
// Perform compression if available
if (context.RequestHeader(Constants.HeaderAcceptEncoding).Contains("gzip"))
{
buffer = buffer.Compress();
context.Response.AddHeader(Constants.HeaderContentEncoding, "gzip");
size = buffer.LongLength;
lrange = 0;
}
}
context.Response.ContentLength64 = size;
try
{
context.Response.OutputStream.Write(buffer, lrange, (int)size);
}
catch (HttpListenerException)
{
// Connection error, nothing else to do
}
}
else
{
context.Response.ContentLength64 = buffer == null
? new FileInfo(localPath).Length
: buffer.LongLength;
}
}
return(true);
}
