| public static IsValidExtension ( string fileName, string extensions ) : bool | ||
| fileName | string | |
| extensions | string | |
| return | bool | |
public ImageViewer(string file)
{
IL.Initialize();
Graphics.Init();
// Extension supported?
if (!ImageViewerUtils.IsValidExtension(file, EXTENSIONS))
{
return;
}
// Save Mouse Position -> will open image at this position
Vector2i mousePos = Mouse.GetPosition();
// Get Image
LoadImage(file);
if (Image == null)
{
return;
}
// Load Config File
Config = new Config();
Config.Load(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "config.txt"));
if (Config.Setting_ListenForConfigChanges)
{
ConfigFileWatcher = new FileSystemWatcher(AppDomain.CurrentDomain.BaseDirectory, "config.txt");
ConfigFileWatcher.NotifyFilter = NotifyFilters.LastWrite;
ConfigFileWatcher.Changed += new FileSystemEventHandler(OnConfigChanged);
ConfigFileWatcher.EnableRaisingEvents = true;
}
// Create Context Menu
ContextMenu = new ContextMenu(this);
ContextMenu.LoadItems(Config.ContextMenu, Config.ContextMenu_Animation, Config.ContextMenu_Animation_InsertAtIndex);
ContextMenu.Setup(false);
// Create Window
Window = new RenderWindow(new VideoMode(Image.Texture.Size.X, Image.Texture.Size.Y), File + " - vimage", Styles.None);
Window.SetActive();
// Make Window Transparent (can only tell if image being viewed has transparency)
DWM_BLURBEHIND bb = new DWM_BLURBEHIND(false);
bb.dwFlags = DWM_BB.Enable;
bb.fEnable = true;
bb.hRgnBlur = new IntPtr();
DWM.DwmEnableBlurBehindWindow(Window.SystemHandle, ref bb);
bool _forceAlwaysOnTop = false;
// Get Bounds
IntRect bounds = ImageViewerUtils.GetCurrentBounds(mousePos);
// Resize Window
if (Config.Setting_LimitImagesToMonitor != Config.NONE)
{
// Fit to monitor height/width
int limit = Config.Setting_LimitImagesToMonitor;
if (limit == Config.AUTO)
{
if (bounds.Height < bounds.Width)
{
limit = Config.HEIGHT;
}
else
{
limit = Config.WIDTH;
}
}
if (limit == Config.HEIGHT && Image.Texture.Size.Y > bounds.Height)
{
Zoom(1 + (((float)bounds.Height - Image.Texture.Size.Y) / Image.Texture.Size.Y), true);
FitToMonitorHeightForced = true;
}
else if (limit == Config.WIDTH && Image.Texture.Size.X > bounds.Width)
{
Zoom(1 + (((float)bounds.Width - Image.Texture.Size.X) / Image.Texture.Size.X), true);
AutomaticallyZoomed = true;
}
}
if (Math.Min(Image.Texture.Size.X, Image.Texture.Size.Y) < Config.Setting_MinImageSize)
{
// Reisze images smaller than min size to min size
AutomaticallyZoomed = true;
Zoom(Config.Setting_MinImageSize / Math.Min(Image.Texture.Size.X, Image.Texture.Size.Y), true);
}
// Use Texture Size * Zoom instead of Window.Size since it wouldn't have updated yet
Vector2i winSize = new Vector2i((int)(Image.Texture.Size.X * CurrentZoom), (int)(Image.Texture.Size.Y * CurrentZoom));
// Position Window
Vector2i winPos;
if (Config.Setting_PositionLargeWideImagesInCorner && CurrentImageSize().X > CurrentImageSize().Y&& CurrentImageSize().X *CurrentZoom >= bounds.Width)
{
// Position Window in top-left if the image is wide (ie: a Desktop Wallpaper / Screenshot)
winPos = new Vector2i(bounds.Left, bounds.Top);
}
else if (Config.Setting_OpenAtMousePosition)
{
// At Mouse Position
winPos = new Vector2i(mousePos.X - (int)(winSize.X / 2), mousePos.Y - (int)(winSize.Y / 2));
if (!FitToMonitorHeightForced)
{
if (winPos.Y < bounds.Top)
{
winPos.Y = 0;
}
else if (winPos.Y + winSize.Y > bounds.Height)
{
winPos.Y = bounds.Height - (int)winSize.Y;
}
}
else
{
winPos.Y = bounds.Top;
}
if (winPos.X < bounds.Left)
{
winPos.X = bounds.Left;
}
else if (winPos.X + winSize.X > bounds.Left + bounds.Width)
{
winPos.X = bounds.Left + bounds.Width - (int)winSize.X;
}
}
else
{
// At Monitor Center
IntRect monitorBounds = ImageViewerUtils.GetCurrentBounds(mousePos);
winPos = new Vector2i(monitorBounds.Left + (int)((monitorBounds.Width - winSize.X) / 2), monitorBounds.Top + (int)((monitorBounds.Height - winSize.Y) / 2));
}
Window.Position = winPos;
// Force Always On Top Mode (so it's above the task bar)
if (FitToMonitorHeightForced || (Image.Texture.Size.Y >= bounds.Height && Image.Texture.Size.X < bounds.Width))
{
_forceAlwaysOnTop = true;
}
// Defaults
// Rotation (some images have a rotation set in their exif data)
RotateImage(DefaultRotation, false);
// Smoothing
if (Image is AnimatedImage)
{
Image.Data.Smooth = Math.Min(Image.Texture.Size.X, Image.Texture.Size.Y) < Config.Setting_SmoothingMinImageSize ? false : Config.Setting_SmoothingDefault;
}
else
{
Image.Texture.Smooth = Math.Min(Image.Texture.Size.X, Image.Texture.Size.Y) < Config.Setting_SmoothingMinImageSize ? false : Config.Setting_SmoothingDefault;
}
// Backgrounds For Images With Transparency
BackgroundsForImagesWithTransparency = Config.Setting_BackgroundForImagesWithTransparencyDefault;
ForceAlwaysOnTopNextTick = _forceAlwaysOnTop;
Redraw();
NextWindowPos = Window.Position;
// Interaction
Window.Closed += OnWindowClosed;
Window.MouseButtonPressed += OnMouseDown;
Window.MouseButtonReleased += OnMouseUp;
Window.MouseWheelMoved += OnMouseWheelMoved;
Window.MouseMoved += OnMouseMoved;
Window.KeyReleased += OnKeyUp;
Window.KeyPressed += OnKeyDown;
// Loop
Stopwatch clock = new Stopwatch();
clock.Start();
while (Window.IsOpen())
{
// Add in some idle time to not thrash the CPU
Thread.Sleep(1);
if (CloseNextTick)
{
Window.Close();
break;
}
// Process events
Window.DispatchEvents();
if (ReloadConfigNextTick)
{
ReloadConfig();
ReloadConfigNextTick = false;
}
// Animated Image?
if (Image is AnimatedImage)
{
bool imageUpdated = Image.Update((float)clock.Elapsed.TotalMilliseconds);
if (!Updated && imageUpdated)
{
Update();
}
}
clock.Restart();
// Drag Window
if (Dragging)
{
Window.Position = new Vector2i(Mouse.GetPosition().X - DragPos.X, Mouse.GetPosition().Y - DragPos.Y);
}
// Update
if (Updated)
{
Updated = false;
Redraw();
Window.Position = NextWindowPos;
}
if (ForceAlwaysOnTopNextTick)
{
bounds = ImageViewerUtils.GetCurrentBounds(Window.Position);
if (Window.Size.Y >= bounds.Height && Window.Size.X < bounds.Width)
{
ForceAlwaysOnTop();
}
else
{
ForceAlwaysOnTopNextTick = false;
}
}
if (PreloadNextImageStart)
{
PreloadNextImage();
}
}
}
///////////////////////////
// Other //
///////////////////////////
private void GetFolderContents()
{
if (FolderContents != null && FolderContents.Count() > 0)
{
return;
}
string[] contents = Directory.GetFiles(File.Substring(0, File.LastIndexOf("\\")));
contents = Array.FindAll(contents, delegate(string s) { return(ImageViewerUtils.IsValidExtension(s, EXTENSIONS)); });
switch (SortImagesBy)
{
case SortBy.Name:
{
// Natural Sorting
Func <string, object> convert = str =>
{
ulong number;
bool success = ulong.TryParse(str.Substring(0, Math.Min(str.Length, 19)), out number);
// max ulong is 18446744073709551615 (20 chars)
if (success)
{
return(number);
}
else
{
return(str);
}
};
if (SortImagesByDir == SortDirection.Ascending)
{
FolderContents.AddRange(contents.OrderBy(
str => Regex.Split(str.Replace(" ", ""), "([0-9]+)").Select(convert),
new EnumerableComparer <object>()));
}
else
{
FolderContents.AddRange(contents.OrderByDescending(
str => Regex.Split(str.Replace(" ", ""), "([0-9]+)").Select(convert),
new EnumerableComparer <object>()));
}
break;
}
case SortBy.DateModified:
{
if (SortImagesByDir == SortDirection.Ascending)
{
FolderContents.AddRange(contents.OrderBy(d => new FileInfo(d).LastWriteTime));
}
else
{
FolderContents.AddRange(contents.OrderByDescending(d => new FileInfo(d).LastWriteTime));
}
break;
}
case SortBy.DateCreated:
{
if (SortImagesByDir == SortDirection.Ascending)
{
FolderContents.AddRange(contents.OrderBy(d => new FileInfo(d).CreationTime));
}
else
{
FolderContents.AddRange(contents.OrderByDescending(d => new FileInfo(d).CreationTime));
}
break;
}
case SortBy.Size:
{
if (SortImagesByDir == SortDirection.Ascending)
{
FolderContents.AddRange(contents.OrderBy(d => new FileInfo(d).Length));
}
else
{
FolderContents.AddRange(contents.OrderByDescending(d => new FileInfo(d).Length));
}
break;
}
}
FolderPosition = FolderContents.IndexOf(File);
}
