public FileCache(LogManager log, IMethodFilter methodFilter, FileCacheManager manager, IFileObject file, int blockSize) {
_log = log;
_dirty = false;
_manager = manager;
_file = file;
_blockSize = blockSize;
_methodFilter = methodFilter;
}
public SevenZipFileSystem(IInArchive archive, IFileName rootName, IFileObject parentLayer, FileSystemOptions fileSystemOptions)
: base(rootName, parentLayer, fileSystemOptions)
{
this.archive = archive;
if (parentLayer.FileSystem is LocalFileSystem || parentLayer.Content.Size > 1048576)
{
file = parentLayer.FileSystem.replicateFile(parentLayer, Selectors.SELECT_SELF);
}
}
public void GetEnumerator_Test()
{
IFileObject[] all = new IFileObject[] { new PDFNumber(1), new PDFNumber(2), new PDFNumber(3) };
PDFArray target = new PDFArray(all);
int index = 0;
foreach (IFileObject found in target)
{
Assert.AreEqual(all[index], found);
index++;
}
}
public void Count_Test()
{
IFileObject[] all = new IFileObject[] { new PDFNumber(1), new PDFNumber(2), new PDFNumber(3) };
PDFArray target = new PDFArray(all);
int expected = all.Length;
int actual = target.Count;
Assert.AreEqual(expected, actual, "PDFArray.Count returned the incorrect value");
target.Add(new PDFNumber(4));
expected += 1;
actual = target.Count;
Assert.AreEqual(expected, actual, "PDFArray.Count returned the incorrect value");
}
public virtual void CopyFrom(IFileObject srcFile)
{
if (srcFile.Type == FileType.File)
{
using (Stream inputStream = srcFile.Content.GetStream(FileAccess.Read))
{
CopyFrom(inputStream);
}
}
if (srcFile.Type == FileType.Folder)
{
CopyFrom(srcFile.GetChildren());
}
}
public static PDFDictionary ParseDictionary(string value, int offset, out int end)
{
AssertValidValue(value, offset + 1);
if (value[offset] != DictionaryStartChar)
{
throw new PDFNativeParserException(CommonErrors.DictionaryDoesNotStartWithRequiredChar);
}
if (value[offset + 1] != DictionaryStartChar)
{
throw new PDFNativeParserException(CommonErrors.DictionaryDoesNotStartWithRequiredChar);
}
PDFDictionary dict = new PDFDictionary();
offset += 2;
while (offset < value.Length)
{
char c = value[offset];
if (char.IsWhiteSpace(c))
{
offset++;
}
else if (c == NameStartCharacter)
{
PDFName name = ParseName(value, offset, out end);
offset = end;
IFileObject obj = InferAndParseNextObject(value, offset, out end);
dict[name] = obj;
offset = end;
}
else if (c == DictionaryEndChar)
{
if (value.Length > offset + 1 && value[offset + 1] == DictionaryEndChar)
{
offset += 2;
break;
}
else
{
throw new PDFNativeParserException(CommonErrors.DictionaryDoesNotEndWithRequiredChar);
}
}
else
{
throw new PDFNativeParserException(CommonErrors.AllDictionaryKeysMustBePDFNames);
}
}
end = offset;
return(dict);
}
public virtual void CreateFile()
{
if (Type == FileType.Imaginary)
{
string fileParentLocalFolder = Path.GetDirectoryName(Name);
if (fileParentLocalFolder.Length > 0)
{
IFileObject parentFolder = MemoryFs.ResolveFile(fileParentLocalFolder);
parentFolder.CreateFolder();
}
}
_Type = FileType.File;
Content.LastModifiedTime = DateTime.Now;
Close();
}
private IEnumerable <IOperation> UpdateFile(IFileObject file, IFileObject baseFile, IChange change, ISyncContext context)
{
if (change is ContentChange)
{
yield return(new CopyFileOperation(baseFile, file, context.ExecutionContext.ServiceContainer.Get <IFileSystem>(), context.ExecutionContext));
}
else if (change is NameCasingChange)
{
yield return(new RenameFileOperation(file, baseFile.Name, context.ExecutionContext.ServiceContainer.Get <IFileSystem>(), context.ExecutionContext));
}
else
{
throw new NotSupportedException();
}
}
private PDFObjectRef[] GetAllPages(PDFObjectRef pageTreeRef, PDFFile origFile)
{
IFileObject fo = origFile.GetContent(pageTreeRef);
if (null == fo || !(fo is PDFDictionary))
{
return new PDFObjectRef[] { }
}
;
PDFDictionary dict = fo as PDFDictionary;
if (null == dict)
{
return new PDFObjectRef[] { }
}
;
PDFName type = dict["Type"] as PDFName;
if (null == type || type.Value != "Pages")
{
return new PDFObjectRef[] { }
}
;
PDFArray kids = dict["Kids"] as PDFArray;
if (null == kids || kids.Count == 0)
{
return new PDFObjectRef[] { }
}
;
List <PDFObjectRef> allPages = new List <PDFObjectRef>();
foreach (IFileObject item in kids)
{
PDFObjectRef pageRef = item as PDFObjectRef;
if (null != pageRef)
{
allPages.Add(pageRef);
}
}
return(allPages.ToArray());
}
void IFileStream.SerializePointer(ref List <IFileObject> value, bool encoded)
{
var count = encoded == false?
this.Stream.ReadValueS32() :
this.Stream.ReadValueEncodedS32();
var list = new List <IFileObject>();
for (int i = 0; i < count; i++)
{
IFileObject item = null;
((IFileStream)this).SerializePointer(ref item);
list.Add(item);
}
value = list;
}
public virtual void CreateFile()
{
if (Type == FileType.Imaginary)
{
if (ParentName.Length > 0)
{
IFileObject parentFolder = DalcFs.ResolveFile(ParentName);
if (parentFolder.Type != FileType.Folder)
{
parentFolder.CreateFolder();
}
}
}
_Type = FileType.File;
Close();
}
private void StatInternal(KStat *s, IFileObject o)
{
s->st_dev = 1;
s->st_ino = 1;
s->st_nlink = 0;
uint flags = 0;
if (o.Stream.CanRead)
{
flags |= S_IRUSR | S_IRGRP | S_IROTH;
}
if (o.Stream.CanWrite)
{
flags |= S_IWUSR | S_IWGRP | S_IWOTH;
}
if (o.Stream.CanSeek)
{
flags |= S_IFREG;
}
else
{
flags |= S_IFIFO;
}
s->st_mode = flags;
s->st_uid = 0;
s->st_gid = 0;
s->__pad0 = 0;
s->st_rdev = 0;
if (o.Stream.CanSeek)
{
s->st_size = o.Stream.Length;
}
else
{
s->st_size = 0;
}
s->st_blksize = 4096;
s->st_blocks = (s->st_size + 511) / 512;
s->st_atime_sec = 1262304000000;
s->st_atime_nsec = 1000000000 / 2;
s->st_mtime_sec = 1262304000000;
s->st_mtime_nsec = 1000000000 / 2;
s->st_ctime_sec = 1262304000000;
s->st_ctime_nsec = 1000000000 / 2;
}
protected IFileObject[] Select(string tableName, QueryNode condition)
{
if (tableName == "." || tableName == Path.AltDirectorySeparatorChar.ToString() || tableName == Path.DirectorySeparatorChar.ToString())
{
tableName = "";
}
IFileObject fileObj = FileSystem.ResolveFile(tableName);
if (fileObj == null)
{
throw new ArgumentException(String.Format("File {0} does not exist", tableName));
}
QueryFileSelector qFileSelector = new QueryFileSelector(false, ConditionEvaluator, condition);
IFileObject[] foundFiles = fileObj.Type == FileType.Folder ? fileObj.FindFiles(qFileSelector) : new IFileObject[0];
return(foundFiles);
}
public static PDFReal Parse(string value, int offset, out int end)
{
IFileObject obj = PDFParserHelper.ParseNumericValue(value, offset, out end);
if (obj.Type == PDFObjectTypes.Real)
{
return((PDFReal)obj);
}
else if (obj.Type == PDFObjectTypes.Number)
{
return(new PDFReal(((PDFNumber)obj).Value));
}
else
{
throw new PDFNativeParserException(CommonErrors.ParsedValueWasNotANumericValue);
}
}
private FindData ToFindData(IFileObject file)
{
var findData = new FindData(Path.GetFileName(file.Name));
var fileInfo = file.GetContent();
if (file.Type == FileType.Folder)
{
findData.Attributes |= FileAttributes.Directory;
}
else
{
findData.FileSize = fileInfo.Size;
}
findData.LastWriteTime = fileInfo.LastModifiedTime;
fileInfo.Close();
return(findData);
}
/// <summary>
/// <see cref="IFileObject.CopyFrom"/>
/// </summary>
protected virtual void CopyFrom(IFileObject[] srcEntries)
{
if (Type == FileType.File)
{
Delete();
}
if (Type == FileType.Imaginary)
{
CreateFolder();
}
foreach (IFileObject srcFile in srcEntries)
{
string destFileName = Path.Combine(Name, Path.GetFileName(srcFile.Name));
IFileObject destFile = LocalFs.ResolveFile(destFileName);
destFile.CopyFrom(srcFile);
}
}
public bool TraverseDescendents(IFileObject file)
{
if (PathPrefix == null)
{
return(true);
}
string fname = file.Name.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar) +
Path.DirectorySeparatorChar;
if (PathPrefix.Length > fname.Length)
{
return(PathPrefix.StartsWith(fname, false, null));
}
else
{
return(fname.StartsWith(PathPrefix, false, null));
}
}
public override object GetEntity(Uri absoluteUri, string role, Type ofObjectToReturn)
{
try {
if ((ofObjectToReturn != null) && (ofObjectToReturn != typeof(Stream)))
{
throw new XmlException("Unsupported object type");
}
string relativePath = AbsoluteBaseUri.MakeRelative(absoluteUri);
var fullPath = Path.Combine(BasePath, relativePath);
if (relativePath.IndexOfAny(new char[] { '*', '?' }) >= 0)
{
// several files
var startPath = MaskFileSelector.GetMaskParentPath(fullPath) ?? String.Empty;
var startFile = FileSystem.ResolveFile(startPath);
var sb = new StringBuilder();
sb.Append("<root>");
var matchedFiles = startFile.FindFiles(new MaskFileSelector(fullPath));
foreach (var f in matchedFiles)
{
using (var input = f.Content.GetStream(FileAccess.Read)) {
var fileText = new StreamReader(input).ReadToEnd();
fileText = MatchXmlDeclaration.Replace(fileText, String.Empty);
sb.Append(fileText);
}
}
sb.Append("</root>");
return(new MemoryStream(Encoding.UTF8.GetBytes(sb.ToString())));
}
else
{
// one file
IFileObject file = FileSystem.ResolveFile(fullPath);
byte[] fileContent;
using (var input = file.Content.GetStream(FileAccess.Read)) {
fileContent = new byte[input.Length];
input.Read(fileContent, 0, fileContent.Length);
}
return(new MemoryStream(fileContent));
}
} catch (Exception ex) {
throw new FileSystemException(String.Format("Cannot resolve {0}: {1}", absoluteUri, ex.Message), ex);
}
}
private IEnumerable <IChange> GetFileChanges(IFileObject file, IFileObject baseFile, ISyncContext context)
{
// TODO: More checks?
if (file.Length != baseFile.Length)
{
yield return(new ContentChange());
}
else if (file.LastWriteTimeUtc != baseFile.LastWriteTimeUtc)
{
// TODO: Make it optional
yield return(new ContentChange());
}
if (!string.Equals(file.ActualName, baseFile.ActualName, StringComparison.Ordinal))
{
yield return(new NameCasingChange());
}
}
public bool IncludeFile(IFileObject file)
{
string normFileName = file.Name.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
string onlyFileName = Path.GetFileName(normFileName);
for (int i = 0; i < Names.Length; i++)
{
bool isFullPath = Names[i].IndexOf(Path.DirectorySeparatorChar) >= 0;
if (isFullPath && Names[i].Equals(normFileName, Comparision))
{
return(true);
}
if (!isFullPath && Names[i].Equals(onlyFileName, Comparision))
{
return(true);
}
}
return(false);
}
public void Remove_Test()
{
IFileObject[] all = new IFileObject[] { new PDFNumber(1), new PDFNumber(2), new PDFNumber(3) };
PDFArray target = new PDFArray(all);
IFileObject toremove = all[1]; //Number 2
bool expected = true;
bool actual;
actual = target.Remove(toremove);
Assert.AreEqual(expected, actual);
Assert.AreEqual(2, target.Count);
toremove = new PDFNumber(4);
expected = false;
actual = target.Remove(toremove);
Assert.AreEqual(expected, actual);
Assert.AreEqual(2, target.Count);
}
private void MoveToPreviousValidImage(int lastGoodIndex)
{
bool foundGoodImage = false;
for (int i = FileIndex; i >= 0; i++)
{
IFileObject currentFile = Files[FileIndex];
if (!IsImage(currentFile))
{
continue;
}
foundGoodImage = true;
FileIndex = i;
}
if (!foundGoodImage)
{
FileIndex = lastGoodIndex;
}
}
public void CopyFrom(IFileObject[] srcEntries)
{
if (Type == FileType.File)
{
Delete();
}
if (Type == FileType.Imaginary)
{
CreateFolder();
}
foreach (IFileObject srcFile in srcEntries)
{
string destFileName = Path.Combine(DalcFs.UnformatPath(Name),
Path.GetFileName(DalcFs.UnformatPath(srcFile.Name)));
IFileObject destFile = DalcFs.ResolveFile(destFileName);
destFile.CopyFrom(srcFile);
}
}
public static PDFArray ParseArray(string value, int offset, out int end)
{
AssertValidValue(value, offset + 1);
if (value[offset] != ArrayStartChar)
{
throw new PDFNativeParserException(CommonErrors.ArrayDoesNotStartWithRequiredChar);
}
PDFArray arry = new PDFArray();
bool ended = false;
offset += 1;
while (offset < value.Length)
{
char c = value[offset];
if (char.IsWhiteSpace(c))
{
offset++;
}
else if (c == ArrayEndChar)
{
offset += 1;
ended = true;
break;
}
else
{
IFileObject obj = InferAndParseNextObject(value, offset, out end);
arry.Add(obj);
offset = end;
}
}
if (!ended)
{
throw new PDFNativeParserException(CommonErrors.ArrayDoesNotEndWithRequiredChar);
}
end = offset;
return(arry);
}
public void Contains_Test()
{
IFileObject[] all = new IFileObject[] { new PDFNumber(1), new PDFNumber(2) };
PDFArray target = new PDFArray(all);
Assert.AreEqual(all[0], all[0], "Basic assertion that PDFNumbers are equal failed");
IFileObject tofind = all[0];
bool contains = target.Contains(tofind);
Assert.IsTrue(contains);
tofind = all[1];
contains = target.Contains(tofind);
Assert.IsTrue(contains);
tofind = new PDFNumber(4);
contains = target.Contains(tofind);
Assert.IsFalse(contains);
}
private void WaitForFileToBeReady(IFileObject file)
{
long start = DateTime.Now.Ticks;
while (true)
{
if (file.IsReady)
{
break;
}
Thread.SpinWait(100);
long now = DateTime.Now.Ticks;
if (now - start > _timeout.Ticks)
{
throw new TimeoutException(
$"File {file} has been locked for more than {_timeout.Seconds} seconds.");
}
}
}
private void SaveInternal(IDictionary data, IFileObject fileObject,
string tableName, string keyFieldName)
{
QueryConditionNode conditions = new QueryConditionNode((QField)keyFieldName,
Conditions.Equal, (QConst)fileObject.Name);
Hashtable recordData = new Hashtable();
int result = Dalc.RecordsCount(new Query(tableName, conditions));
if (result > 0)
{
if (data.Contains(keyFieldName))
{
data.Remove(keyFieldName); // fixed DB bug on update
}
Dalc.Update(new Query(tableName, conditions), data);
}
else
{
Dalc.Insert(tableName, data);
}
}
protected virtual IFileObject GetUniqueFile(IFileSystem fs, string fileName)
{
int fileNum = 0;
IFileObject uniqueFile = null;
do
{
fileNum++;
var extIdx = fileName.LastIndexOf('.');
var newFileName = extIdx >= 0 ? String.Format("{0}{1}{2}", fileName.Substring(0, extIdx), fileNum, fileName.Substring(extIdx)) : fileName + fileNum.ToString();
uniqueFile = fs.ResolveFile(newFileName);
} while (uniqueFile.Exists() && fileNum < 100);
if (uniqueFile.Exists())
{
var extIdx = fileName.LastIndexOf('.');
var uniqueSuffix = Guid.NewGuid().ToString();
uniqueFile = fs.ResolveFile(
extIdx >= 0 ? fileName.Substring(0, extIdx) + uniqueSuffix + fileName.Substring(extIdx) : fileName + uniqueSuffix);
}
return(uniqueFile);
}
protected IFileObject GetThumbnail(IFileObject originalFile, IFileSystem filesystem, string width, string height)
{
var resizeWidth = AssertHelper.IsFuzzyEmpty(width) ? 0 : Convert.ToInt32(width);
var resizeHeight = AssertHelper.IsFuzzyEmpty(height) ? 0 : Convert.ToInt32(height);
if (resizeWidth == 0 && resizeHeight == 0)
{
return(originalFile);
}
var thumbnailFileName = String.Format("{0}-thumbnail{1}x{2}{3}",
Path.Combine(Path.GetDirectoryName(originalFile.Name), Path.GetFileNameWithoutExtension(originalFile.Name)),
resizeWidth,
resizeHeight,
Path.GetExtension(originalFile.Name)
);
var thumbnailFile = filesystem.ResolveFile(thumbnailFileName);
return(!thumbnailFile.Exists()
? ImageHelper.SaveAndResizeImage(originalFile.GetContent().InputStream, filesystem, thumbnailFile, resizeWidth, resizeHeight)
: thumbnailFile);
}
protected object GetFileObjectField(string name, IFileObject file)
{
if (name == "is_file")
{
return(file.Type == FileType.File);
}
if (name == "is_folder")
{
return(file.Type == FileType.Folder);
}
string fName = file.Name.Replace('\\', '/');
if (name == "name")
{
return(Path.GetFileName(fName));
}
if (name == "full_name")
{
return(fName);
}
if (name == "ext")
{
return(Path.GetExtension(fName));
}
if (name == "folder_name")
{
return(Path.GetDirectoryName(fName));
}
IFileContent fContent = file.Content;
if (name == "size")
{
return(fContent.Size);
}
if (name == "last_modified")
{
return(fContent.LastModifiedTime);
}
throw new ArgumentException("Unknown field name: " + name);
}
public virtual IFileObject[] GetChildren()
{
if (Type != FileType.Folder)
{
throw new FileSystemException("Folder does not exist"); // TODO: more structured exception
}
ChildrenList childrenList = GetChildrenList();
string[] fileEntries = childrenList.FileEntries;
string[] directoryEntries = childrenList.DirectoryEntries;
IFileObject[] children = new IFileObject[fileEntries.Length + directoryEntries.Length];
for (int i = 0; i < directoryEntries.Length; i++)
{
children[i] = LocalFs.ResolveFile(Path.Combine(Name, Path.GetFileName(directoryEntries[i])), FileType.Folder);
}
for (int i = 0; i < fileEntries.Length; i++)
{
children[directoryEntries.Length + i] = LocalFs.ResolveFile(Path.Combine(Name, Path.GetFileName(fileEntries[i])), FileType.File);
}
return(children);
}
/// <summary>
/// <see cref="IFileObject.MoveTo"/>
/// </summary>
public virtual void MoveTo(IFileObject destFile)
{
// raise 'before move'
LocalFs.OnFileMoving(this, destFile);
try {
if (destFile is LocalFile)
{
// delete destination file
if (destFile.Type != FileType.Imaginary)
{
destFile.Delete();
}
// use fast API move functions...
if (Type == FileType.File)
{
File.Move(LocalName, ((LocalFile)destFile).LocalName);
}
if (Type == FileType.Folder)
{
Directory.Move(LocalName, ((LocalFile)destFile).LocalName);
}
}
else
{
// copy-delete
destFile.CopyFrom(this);
this.Delete();
}
} catch (Exception ex) {
// raise 'error'
LocalFs.OnFileError(this, ex);
throw new FileSystemException(ex.Message, this, ex);
}
// raise 'after move'
LocalFs.OnFileMoved(this, destFile);
}
public ImageFile(IFileObject file)
{
File = file;
}
protected override IFileSystem doCreateFileSystem(String scheme, IFileObject file, FileSystemOptions fileSystemOptions)
{
if(!formatMap.ContainsKey(scheme))
{
throw new FileSystemException(String.Format("Unknown file system scheme: {0}", scheme));
}
IInArchive archive = sevenZip.CreateInArchive(SevenZipFormat.GetClassIdFromKnownFormat(formatMap[scheme]));
if(archive == null)
{
throw new FileSystemException("This 7-zip library does not support this archive type.");
}
IFileName rootName = new LayeredFileName(scheme, file.Name, FileName_Fields.ROOT_PATH, FileType.FOLDER);
SevenZipFileSystem fs = new SevenZipFileSystem(archive, rootName, file, fileSystemOptions);
foreach (IFileSystemListener listener in defaultListeners)
{
fs.addListener(listener);
}
return fs;
}
public DirectFileCache(IFileObject file) {
_file = file;
}
public ArchiveOpenCallback(SevenZipFileSystem fileSystem, IFileObject parent, FileInfo archiveFile)
{
this.fileSystem = fileSystem;
this.parent = parent;
this.archiveFile = archiveFile;
this.streams = new List<Stream>();
}
private void ProcessDirectory(IFileObject directory, bool includeSubDirs)
{
IFileObject[] files = directory.findFiles(Selectors.SELECT_CHILDREN);
if (files == null)
{
return;
}
foreach (IFileObject file in files)
{
if (this.excludeList.ContainsKey(file.Name.URI))
{
continue;
}
if (file.Type == FileType.FILE)
{
IFileName name = file.Name;
string extension = name.Extension;
switch (extension)
{
case "fb2":
ImportFileEntry entry = new ImportFileEntry(chkSelectFoundFiles.Checked, name.BaseName, name.URI);
entry.Status = ImportStatus.ReadyToProcess;
if (entry.Selected)
{
this.processLegend.IncrementCounter(ImportStatus.ReadyToProcess);
this.grdLegend.RefreshDataSource();
}
this.fileEntries.Add(entry);
this.excludeList.Add(file.Name.URI, entry);
break;
case "zip":
String url = "zip:" + name.URI + "!/";
//string filename = Path.ChangeExtension(name.BaseName, null);
//if(String.Compare(Path.GetExtension(filename), ".fb2", true) == 0)
//{
// if (this.excludeList.ContainsKey(url + filename))
// {
// continue;
// }
// entry = new ImportFileEntry(chkSelectFoundFiles.Checked, filename, url + filename);
// entry.Status = ImportStatus.ReadyToProcess;
// if (entry.Selected)
// {
// this.processLegend.IncrementCounter(ImportStatus.ReadyToProcess);
// this.grdLegend.RefreshDataSource();
// }
// this.fileEntries.Add(entry);
// this.excludeList.Add(entry.Uri, entry);
// break;
//}
IFileObject zipFile = manager.resolveFile(url);
ProcessDirectory(zipFile, true);
break;
case "7z":
IFileObject sevenZipFile = manager.resolveFile("sevenzip:" + name.URI + "!/");
ProcessDirectory(sevenZipFile, true);
break;
case "rar":
IFileObject rarFile = manager.resolveFile("rar:" + name.URI + "!/");
ProcessDirectory(rarFile, true);
break;
}
}
else if (file.Type == FileType.FOLDER && includeSubDirs)
{
ProcessDirectory(file, true);
}
}
}
private void ShowBookPreview(IFileObject fileObject)
{
Cursor = Cursors.WaitCursor;
try
{
using (Stream stream = fileObject.Content.InputStream)
{
try
{
ShowBookPreview(stream);
}
finally
{
stream.Close();
}
}
}
finally
{
Cursor = Cursors.Default;
}
}
public static IFileObject SaveAndResizeImage(Stream input, IFileSystem fs, IFileObject file, int maxWidth, int maxHeight, ImageFormat saveAsFormat )
{
Image img;
MemoryStream imgSrcStream = new MemoryStream();
byte[] buf = new byte[1024*50];
int bufRead = 0;
do {
bufRead = input.Read(buf, 0, buf.Length);
if (bufRead>0)
imgSrcStream.Write(buf, 0, bufRead);
} while (bufRead>0);
imgSrcStream.Position = 0;
try {
img = Image.FromStream(imgSrcStream);
} catch (Exception ex) {
throw new Exception( WebManager.GetLabel("Invalid image format") );
}
if (img.Size.Width==0 || img.Size.Height==0)
throw new Exception( WebManager.GetLabel("Invalid image size") );
var sizeIsWidthOk = (maxWidth<=0 || img.Size.Width<=maxWidth);
var sizeIsHeightOk = (maxHeight<=0 || img.Size.Height<=maxHeight);
var sizeIsOk = sizeIsWidthOk && sizeIsHeightOk;
var originalImgFmt = ResolveImageFormat( Path.GetExtension(file.Name) ) ?? ImageFormat.Bmp;
var formatIsOk = (saveAsFormat==null && !originalImgFmt.Equals(ImageFormat.Bmp) && !originalImgFmt.Equals(ImageFormat.Tiff) ) || originalImgFmt.Equals(saveAsFormat);
if (!formatIsOk || !sizeIsOk ) {
var saveAsFormatResolved = saveAsFormat!=null ? saveAsFormat : (originalImgFmt==ImageFormat.Jpeg?ImageFormat.Jpeg:ImageFormat.Png);
var newFmtExtension = GetImageFormatExtension(saveAsFormatResolved);
var newFile = fs.ResolveFile( file.Name + (Path.GetExtension(file.Name).ToLower()==newFmtExtension ? String.Empty : newFmtExtension) );
newFile.CreateFile();
if (!sizeIsOk) {
var newWidth = img.Size.Width;
var newHeight = img.Size.Height;
if (!sizeIsWidthOk) {
newWidth = maxWidth;
newHeight = (int) Math.Floor( ((double)img.Size.Height)*( ((double)maxWidth)/((double)img.Size.Width) ) );
if ( maxHeight<0 || newHeight<=maxHeight )
sizeIsHeightOk = true;
}
if (!sizeIsHeightOk) {
newHeight = maxHeight;
newWidth = (int) Math.Floor( ((double)img.Size.Width)*( ((double)maxHeight)/((double)img.Size.Height) ) );
}
var resizedBitmap = new Bitmap(img, newWidth, newHeight);
var imageProps = img.PropertyItems;
foreach (PropertyItem propItem in imageProps){
resizedBitmap.SetPropertyItem(propItem);
}
SaveImage(resizedBitmap, newFile.GetContent().OutputStream, saveAsFormatResolved);
} else {
SaveImage(img, newFile.GetContent().OutputStream, saveAsFormatResolved );
}
newFile.Close();
return newFile;
}
file.CreateFile();
imgSrcStream.Position = 0;
file.CopyFrom( imgSrcStream );
file.Close();
return file;
}
public static IFileObject SaveCompressedImage(Stream input, IFileSystem fs, IFileObject file)
{
return SaveAndResizeImage(input, fs, file, 0, 0);
}
public static IFileObject SaveAndResizeImage(Stream input, IFileSystem fs, IFileObject file, int maxWidth, int maxHeight )
{
return SaveAndResizeImage(input,fs,file,maxWidth,maxHeight,null);
}
private FindData ToFindData(IFileObject file)
{
var findData = new FindData(Path.GetFileName(file.Name));
var fileInfo = file.GetContent();
if (file.Type == FileType.Folder) findData.Attributes |= FileAttributes.Directory;
else findData.FileSize = fileInfo.Size;
findData.LastWriteTime = fileInfo.LastModifiedTime;
fileInfo.Close();
return findData;
}
public static bool IsImage(IFileObject file)
{
return _ImageFileExtensions.Contains(file.Extension);
}
