2178 lines
82 KiB
C#
2178 lines
82 KiB
C#
using Microsoft.VisualBasic.FileIO;
|
|
using Mk0.GUI.Banner;
|
|
using Mk0.Software.ImageSorter.Properties;
|
|
using Mk0.Tools.Calculation;
|
|
using Mk0.Tools.FileAssociaton;
|
|
using Mk0.Tools.Images;
|
|
using Mk0.Tools.Randomization;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Diagnostics;
|
|
using System.Drawing;
|
|
using System.Drawing.Imaging;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using System.Windows.Forms;
|
|
using Mk0.Software.OnlineUpdater;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace Mk0.Software.ImageSorter
|
|
{
|
|
public partial class Main : Form
|
|
{
|
|
public string quellPath = "";
|
|
public string zielPath = "";
|
|
private string[] fileTypes = { ".jpg", ".png", ".jpeg", ".gif", ".tif", ".tiff", ".bmp", ".webp", ".heic" };
|
|
private int moved = 0;
|
|
private int imageIndex;
|
|
private List<Button> buttons = new List<Button>();
|
|
private List<string> images = new List<string>();
|
|
private List<string> history = new List<string>();
|
|
private bool moving;
|
|
private bool moveable = false;
|
|
private Point startLocation; //verschieben
|
|
private Cursor grabCursor = new Cursor(new MemoryStream(Resources.grab));
|
|
private Cursor grabbingCursor = new Cursor(new MemoryStream(Resources.grabbing));
|
|
private double xFaktor = 0.0;
|
|
private double yFaktor = 0.0;
|
|
private static object locker = new object();
|
|
private Thread folderThread;
|
|
private bool threadIsRunning = false;
|
|
private Banner banner;
|
|
private string startuppath;
|
|
private string startupimage;
|
|
public string[] Args;
|
|
private FormWindowState lastState = FormWindowState.Minimized;
|
|
private string defaultWindowName;
|
|
|
|
public Main()
|
|
{
|
|
InitializeComponent();
|
|
defaultWindowName = Text;
|
|
banner = new Banner(components, panelBanner, pictureBoxBanner1, pictureBoxBanner2, labelBanner1, labelBanner2);
|
|
pictureBoxImage.Cursor = grabCursor;
|
|
DoubleBuffered = true;
|
|
SetDefaultPath();
|
|
comboBoxZoom.SelectedIndex = Properties.Settings.Default.zoom;
|
|
|
|
//file assoc prüfen und in einstellungen richtig setzen
|
|
if(FileAssociation.Check("Image_Sorter_JPG", Application.ExecutablePath, "JPG Bild", $@"{Application.StartupPath}\AssocIcons\jpg.ico") &&
|
|
FileAssociation.Check("Image_Sorter_PNG", Application.ExecutablePath, "PNG Bild", $@"{Application.StartupPath}\AssocIcons\png.ico") &&
|
|
FileAssociation.Check("Image_Sorter_GIF", Application.ExecutablePath, "GIF Bild", $@"{Application.StartupPath}\AssocIcons\gif.ico") &&
|
|
FileAssociation.Check("Image_Sorter_JPEG", Application.ExecutablePath, "JPEG Bild", $@"{Application.StartupPath}\AssocIcons\jpeg.ico") &&
|
|
FileAssociation.Check("Image_Sorter_BMP", Application.ExecutablePath, "BMP Bild", $@"{Application.StartupPath}\AssocIcons\bmp.ico") &&
|
|
FileAssociation.Check("Image_Sorter_TIF", Application.ExecutablePath, "TIF Bild", $@"{Application.StartupPath}\AssocIcons\tif.ico") &&
|
|
FileAssociation.Check("Image_Sorter_TIFF", Application.ExecutablePath, "TIFF Bild", $@"{Application.StartupPath}\AssocIcons\tiff.ico") &&
|
|
FileAssociation.Check("Image_Sorter_WEBP", Application.ExecutablePath, "WEBP Bild", $@"{Application.StartupPath}\AssocIcons\webp.ico") &&
|
|
FileAssociation.Check("Image_Sorter_HEIC", Application.ExecutablePath, "HEIC Bild", $@"{Application.StartupPath}\AssocIcons\heic.ico"))
|
|
{
|
|
Properties.Settings.Default.fileAssociation = true;
|
|
}
|
|
else
|
|
{
|
|
Properties.Settings.Default.fileAssociation = false;
|
|
}
|
|
Properties.Settings.Default.Save();
|
|
}
|
|
|
|
private void Main_Load(object sender, EventArgs e)
|
|
{
|
|
if (Args != null)
|
|
{
|
|
ProcessParameters(null, Args);
|
|
Args = null;
|
|
}
|
|
|
|
AutoUpdater.ShowSkipButton = false;
|
|
AutoUpdater.Start("https://www.kmpr.at/update/imagesorter.xml");
|
|
}
|
|
|
|
public delegate void ProcessParametersDelegate(object sender, string[] args);
|
|
public void ProcessParameters(object sender, string[] args)
|
|
{
|
|
if (args != null && args.Length != 0)
|
|
{
|
|
if (!string.IsNullOrEmpty(args[0]) && File.Exists(args[0]))
|
|
{
|
|
startuppath = Path.GetDirectoryName(args[0]);
|
|
startupimage = Path.GetFileName(args[0]);
|
|
if (!string.IsNullOrEmpty(startuppath) && File.Exists(startuppath))
|
|
{
|
|
startuppath = Path.GetDirectoryName(startuppath);
|
|
startupimage = Path.GetFileName(startuppath);
|
|
}
|
|
SetDefaultPath();
|
|
SearchImages();
|
|
CountPicsInPath();
|
|
LoadPicture(GetImageIndex(Path.Combine(startuppath, startupimage)));
|
|
ShowPreviewImages();
|
|
if (WindowState != FormWindowState.Normal || WindowState != FormWindowState.Maximized)
|
|
{
|
|
if (lastState != FormWindowState.Minimized) { WindowState = lastState; } else { WindowState = FormWindowState.Normal; }
|
|
}
|
|
Activate();
|
|
BringToFront();
|
|
TopMost = true;
|
|
TopMost = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Extrahiert die Icons für die Fileassociation
|
|
/// </summary>
|
|
private void ExtractAssocIcons()
|
|
{
|
|
Directory.CreateDirectory($@"{Application.StartupPath}\AssocIcons");
|
|
WriteResource($@"{Application.StartupPath}\AssocIcons\jpg.ico", Resources.jpg);
|
|
WriteResource($@"{Application.StartupPath}\AssocIcons\png.ico", Resources.png);
|
|
WriteResource($@"{Application.StartupPath}\AssocIcons\gif.ico", Resources.gif);
|
|
WriteResource($@"{Application.StartupPath}\AssocIcons\jpeg.ico", Resources.jpeg);
|
|
WriteResource($@"{Application.StartupPath}\AssocIcons\bmp.ico", Resources.bmp);
|
|
WriteResource($@"{Application.StartupPath}\AssocIcons\tif.ico", Resources.tif);
|
|
WriteResource($@"{Application.StartupPath}\AssocIcons\tiff.ico", Resources.tiff);
|
|
WriteResource($@"{Application.StartupPath}\AssocIcons\webp.ico", Resources.webp);
|
|
WriteResource($@"{Application.StartupPath}\AssocIcons\heic.ico", Resources.heic);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Helfer um Resources auf die Platte zu schreiben
|
|
/// </summary>
|
|
/// <param name="path">Zielpfad</param>
|
|
/// <param name="icon">Resource</param>
|
|
private void WriteResource(string path, Icon icon)
|
|
{
|
|
using (var fileStream = new FileStream(path, FileMode.Create))
|
|
{
|
|
icon.Save(fileStream);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Default: Lädt das erste Bild
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void Main_Shown(object sender, EventArgs e)
|
|
{
|
|
if (Properties.Settings.Default.fullScreen)
|
|
{
|
|
WindowState = FormWindowState.Maximized;
|
|
}
|
|
else
|
|
{
|
|
if (Properties.Settings.Default.lastHeight >= MinimumSize.Height)
|
|
{
|
|
Height = Properties.Settings.Default.lastHeight;
|
|
}
|
|
if (Properties.Settings.Default.lastWidth >= MinimumSize.Width)
|
|
{
|
|
Width = Properties.Settings.Default.lastWidth;
|
|
}
|
|
if (Properties.Settings.Default.lastTop <= Screen.PrimaryScreen.Bounds.Height && Properties.Settings.Default.lastTop >= 0)
|
|
{
|
|
Top = Properties.Settings.Default.lastTop;
|
|
}
|
|
if (Properties.Settings.Default.lastLeft <= Screen.PrimaryScreen.Bounds.Width && Properties.Settings.Default.lastLeft >= 0)
|
|
{
|
|
Left = Properties.Settings.Default.lastLeft;
|
|
}
|
|
}
|
|
groupBoxInformationen.Visible = Properties.Settings.Default.showInfo;
|
|
if (!groupBoxInformationen.Visible)
|
|
{
|
|
groupBoxZiele.Location = new Point(groupBoxZiele.Location.X, 12);
|
|
groupBoxZiele.Height += 87;
|
|
}
|
|
CheckSubfolders();
|
|
SearchImages();
|
|
CountPicsInPath();
|
|
if (string.IsNullOrEmpty(startupimage))
|
|
{
|
|
LoadPicture(0);
|
|
}
|
|
else
|
|
{
|
|
LoadPicture(GetImageIndex(Path.Combine(startuppath, startupimage)));
|
|
}
|
|
ResetUndo();
|
|
panelImageBackground.BackColor = Properties.Settings.Default.lightBackgroundColour;
|
|
pictureBoxImage.BackColor = Properties.Settings.Default.lightBackgroundColour;
|
|
if (Properties.Settings.Default.preview)
|
|
{
|
|
panelImageBackground.Height -= 100;
|
|
ShowPreviewImages();
|
|
panelPreview.Visible = true;
|
|
}
|
|
//Christmas Easteregg
|
|
if (DateTime.Now.Month == 12 && DateTime.Now.Day >= 24 && DateTime.Now.Day <= 27)
|
|
{
|
|
buttonChristmas.Visible = true;
|
|
}
|
|
//End
|
|
ToolTip t1 = new ToolTip
|
|
{
|
|
AutoPopDelay = 5000,
|
|
InitialDelay = 1000,
|
|
ReshowDelay = 500
|
|
};
|
|
t1.SetToolTip(buttonJumpBack, "Voriges Bild");
|
|
ToolTip t2 = new ToolTip
|
|
{
|
|
AutoPopDelay = 5000,
|
|
InitialDelay = 1000,
|
|
ReshowDelay = 500
|
|
};
|
|
t2.SetToolTip(buttonJumpForward, "Nächstes Bild");
|
|
ToolTip t3 = new ToolTip
|
|
{
|
|
AutoPopDelay = 5000,
|
|
InitialDelay = 1000,
|
|
ReshowDelay = 500
|
|
};
|
|
t3.SetToolTip(buttonUndo, "Aktion Rückgängig machen");
|
|
ToolTip t4 = new ToolTip
|
|
{
|
|
AutoPopDelay = 5000,
|
|
InitialDelay = 1000,
|
|
ReshowDelay = 500
|
|
};
|
|
t4.SetToolTip(buttonSettings, "Einstellungen öffnen (F10)");
|
|
ToolTip t5 = new ToolTip
|
|
{
|
|
AutoPopDelay = 5000,
|
|
InitialDelay = 1000,
|
|
ReshowDelay = 500
|
|
};
|
|
t5.SetToolTip(buttonQuellPfad, "Quellpfad festlegen (Q)");
|
|
ToolTip t6 = new ToolTip
|
|
{
|
|
AutoPopDelay = 5000,
|
|
InitialDelay = 1000,
|
|
ReshowDelay = 500
|
|
};
|
|
t6.SetToolTip(buttonInfo, "Informationen ein-/ausblenden (I)");
|
|
ToolTip t7 = new ToolTip
|
|
{
|
|
AutoPopDelay = 5000,
|
|
InitialDelay = 1000,
|
|
ReshowDelay = 500
|
|
};
|
|
t7.SetToolTip(buttonDateirenamer, "Dateirenamer öffnen (F12)");
|
|
ToolTip t8 = new ToolTip
|
|
{
|
|
AutoPopDelay = 5000,
|
|
InitialDelay = 1000,
|
|
ReshowDelay = 500
|
|
};
|
|
t8.SetToolTip(buttonRander, "Ränder manuell beschneiden (R)");
|
|
ToolTip t9 = new ToolTip
|
|
{
|
|
AutoPopDelay = 5000,
|
|
InitialDelay = 1000,
|
|
ReshowDelay = 500
|
|
};
|
|
t9.SetToolTip(buttonDuplicate, "Duplizieren (D)");
|
|
ToolTip t10 = new ToolTip
|
|
{
|
|
AutoPopDelay = 5000,
|
|
InitialDelay = 1000,
|
|
ReshowDelay = 500
|
|
};
|
|
t10.SetToolTip(buttonDeleteImage, "Löschen (Entf)");
|
|
ToolTip t11 = new ToolTip
|
|
{
|
|
AutoPopDelay = 5000,
|
|
InitialDelay = 1000,
|
|
ReshowDelay = 500
|
|
};
|
|
t11.SetToolTip(buttonHintergrund, "Hintergrund hell/dunkel umschalten (H)");
|
|
ToolTip t12 = new ToolTip
|
|
{
|
|
AutoPopDelay = 5000,
|
|
InitialDelay = 1000,
|
|
ReshowDelay = 500
|
|
};
|
|
t12.SetToolTip(buttonTransformation, "Transformation (T)");
|
|
ToolTip t13 = new ToolTip
|
|
{
|
|
AutoPopDelay = 5000,
|
|
InitialDelay = 1000,
|
|
ReshowDelay = 500
|
|
};
|
|
t13.SetToolTip(buttonMirrorHorizontal, "Horizontal spiegeln");
|
|
ToolTip t14 = new ToolTip
|
|
{
|
|
AutoPopDelay = 5000,
|
|
InitialDelay = 1000,
|
|
ReshowDelay = 500
|
|
|
|
};
|
|
t14.SetToolTip(buttonMirrorVertikal, "Vertikal spiegeln");
|
|
ToolTip t15 = new ToolTip
|
|
{
|
|
AutoPopDelay = 5000,
|
|
InitialDelay = 1000,
|
|
ReshowDelay = 500
|
|
};
|
|
t15.SetToolTip(buttonRotate90, "Drehen 90°");
|
|
ToolTip t16 = new ToolTip
|
|
{
|
|
AutoPopDelay = 5000,
|
|
InitialDelay = 1000,
|
|
ReshowDelay = 500
|
|
};
|
|
t16.SetToolTip(buttonRotate180, "Drehen 180°");
|
|
ToolTip t17 = new ToolTip
|
|
{
|
|
AutoPopDelay = 5000,
|
|
InitialDelay = 1000,
|
|
ReshowDelay = 500
|
|
};
|
|
t17.SetToolTip(buttonRotate270, "Drehen 270°");
|
|
ToolTip t18 = new ToolTip
|
|
{
|
|
AutoPopDelay = 5000,
|
|
InitialDelay = 1000,
|
|
ReshowDelay = 500
|
|
};
|
|
t18.SetToolTip(buttonRandOben, "Oben (Ctrl+Auf)");
|
|
ToolTip t19 = new ToolTip
|
|
{
|
|
AutoPopDelay = 5000,
|
|
InitialDelay = 1000,
|
|
ReshowDelay = 500
|
|
};
|
|
t19.SetToolTip(buttonRandUnten, "Unten (Ctrl+Ab)");
|
|
ToolTip t20 = new ToolTip
|
|
{
|
|
AutoPopDelay = 5000,
|
|
InitialDelay = 1000,
|
|
ReshowDelay = 500
|
|
};
|
|
t20.SetToolTip(buttonRandRechts, "Rechts (Ctrl+Rechts)");
|
|
ToolTip t21 = new ToolTip
|
|
{
|
|
AutoPopDelay = 5000,
|
|
InitialDelay = 1000,
|
|
ReshowDelay = 500
|
|
};
|
|
t21.SetToolTip(buttonRandLinks, "Links (Ctrl+Links)");
|
|
ToolTip t22 = new ToolTip
|
|
{
|
|
AutoPopDelay = 5000,
|
|
InitialDelay = 1000,
|
|
ReshowDelay = 500
|
|
};
|
|
t22.SetToolTip(buttonPreview, "Bildvorschau (P)");
|
|
ToolTip t23 = new ToolTip
|
|
{
|
|
AutoPopDelay = 5000,
|
|
InitialDelay = 1000,
|
|
ReshowDelay = 500
|
|
};
|
|
t23.SetToolTip(buttonHeart, "Unterstütze dieses Projekt");
|
|
ToolTip t24 = new ToolTip
|
|
{
|
|
AutoPopDelay = 5000,
|
|
InitialDelay = 1000,
|
|
ReshowDelay = 500
|
|
};
|
|
t24.SetToolTip(buttonChristmas, "Frohe Weihnachten!");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Startpfad auf letzten Pfad legen, wenn Bilder vorhanden sind, sonst auf Bild-Bibliothek, wenn da auch keine sind, dann den Applikationspfad
|
|
/// </summary>
|
|
private void SetDefaultPath()
|
|
{
|
|
string tmpPath = Application.StartupPath;
|
|
|
|
if (string.IsNullOrEmpty(startuppath))
|
|
{
|
|
if (!string.IsNullOrEmpty(Properties.Settings.Default.lastPath) && Directory.Exists(Properties.Settings.Default.lastPath))
|
|
{
|
|
tmpPath = Properties.Settings.Default.lastPath;
|
|
}
|
|
|
|
int picsHere = 0;
|
|
foreach (string type in fileTypes)
|
|
{
|
|
var list = Directory.GetFiles(tmpPath, "*." + type);
|
|
if (list.Length > 0)
|
|
{
|
|
picsHere += list.Length;
|
|
}
|
|
}
|
|
|
|
string myPics = Environment.GetFolderPath(Environment.SpecialFolder.MyPictures);
|
|
if (Directory.Exists(myPics) && picsHere == 0)
|
|
{
|
|
tmpPath = myPics;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
tmpPath = startuppath;
|
|
}
|
|
|
|
quellPath = tmpPath;
|
|
labelQuellPath.Text = tmpPath;
|
|
|
|
if (!string.IsNullOrEmpty(Properties.Settings.Default.targetPath))
|
|
{
|
|
zielPath = Properties.Settings.Default.targetPath;
|
|
labelZielPath.Text = Properties.Settings.Default.targetPath;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Wenn Subfolders vorhanden, Text ausblenden und für jeden Subfolder einen Button anlegen
|
|
/// </summary>
|
|
private void CheckSubfolders()
|
|
{
|
|
if (!threadIsRunning)
|
|
{
|
|
folderThread = new Thread(new ThreadStart(CheckSubfoldersThread))
|
|
{
|
|
IsBackground = true
|
|
};
|
|
folderThread.Start();
|
|
}
|
|
}
|
|
|
|
private void CheckSubfoldersThread()
|
|
{
|
|
threadIsRunning = true;
|
|
try
|
|
{
|
|
var folders = Directory.GetDirectories(zielPath, "*", System.IO.SearchOption.TopDirectoryOnly);
|
|
DirectoryInfo di = new DirectoryInfo(zielPath);
|
|
int dircount = di.GetDirectories().Length;
|
|
Invoke(new dlgRefreshButtons(RefreshButtons), dircount, folders);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
}
|
|
finally
|
|
{
|
|
threadIsRunning = false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Erstellt für jeden Subfolder einen Button zum verschieben
|
|
/// </summary>
|
|
/// <param name="dircount"></param>
|
|
/// <param name="folders"></param>
|
|
private void RefreshButtons(int dircount, string[] folders)
|
|
{
|
|
RemoveButtons(buttons);
|
|
buttons.Clear();
|
|
if (dircount > 0)
|
|
{
|
|
labelNoTargets.Visible = false;
|
|
AddButtons(folders);
|
|
}
|
|
else
|
|
{
|
|
labelNoTargets.Visible = true;
|
|
}
|
|
}
|
|
|
|
public delegate void dlgRefreshButtons(int dircount, string[] folders);
|
|
|
|
/// <summary>
|
|
/// Fügt Buttons aus array hinzu
|
|
/// </summary>
|
|
/// <param name="folders"></param>
|
|
private void AddButtons(string[] folders, int top = 9, int left = 9)
|
|
{
|
|
Array.Sort(folders);
|
|
foreach (string folder in folders)
|
|
{
|
|
if (Path.GetFileNameWithoutExtension(folder).ToString() != "$RECYCLE" && Path.GetFileNameWithoutExtension(folder).ToString() != "System Volume Information" && Path.GetFileNameWithoutExtension(folder).ToString() != "ImageSorter" && Path.GetFileNameWithoutExtension(folder).ToString() != "Image Sorter" && Path.GetFileNameWithoutExtension(folder).ToString() != "AssocIcons")
|
|
{
|
|
Button button = new Button
|
|
{
|
|
Left = left,
|
|
Top = top
|
|
};
|
|
int count = 0;
|
|
button.Text = Path.GetFileNameWithoutExtension(folder).ToString() + " (" + count + ")";
|
|
button.Size = new Size(225, 30);
|
|
button.Click += new EventHandler(MovePicture);
|
|
System.Timers.Timer tx = new System.Timers.Timer(35);
|
|
tx.Elapsed += new System.Timers.ElapsedEventHandler((sender1, e1) => ButtonFade(button, tx));
|
|
button.Tag = tx;
|
|
buttons.Add(button);
|
|
top += button.Height + 2;
|
|
}
|
|
}
|
|
|
|
foreach (Button button in this.buttons)
|
|
{
|
|
panelButtons.Controls.Add(button);
|
|
}
|
|
|
|
AsyncCountFilesInFolders();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Zählt die Files in den Folders asynchron und addiert anschließend die Zahl zum Button-Text hinzu
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private async Task AsyncCountFilesInFolders()
|
|
{
|
|
await Task.Run(() =>
|
|
{
|
|
foreach (Control ctl in panelButtons.Controls)
|
|
{
|
|
if (ctl is Button)
|
|
{
|
|
try
|
|
{
|
|
string[] folderButton = ctl.Text.Split('(');
|
|
int count = int.Parse(folderButton[1].Substring(0, folderButton[1].Length - 1)); //sollte das nicht später gezählt werden??
|
|
string targetPath = Path.Combine(zielPath, folderButton[0].Substring(0, folderButton[0].Length - 1));
|
|
foreach (string file in Directory.EnumerateFiles(targetPath, "*.*", System.IO.SearchOption.AllDirectories).Where(s => fileTypes.Any(ext => ext == Path.GetExtension(s))))
|
|
{
|
|
count++;
|
|
}
|
|
if (ctl.InvokeRequired)
|
|
ctl.Invoke(new Action(() => ctl.Text = folderButton[0] + "(" + count + ")"));
|
|
else
|
|
ctl.Text = folderButton[0] + "(" + count + ")";
|
|
}
|
|
catch (Exception)
|
|
{
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
/// <summary>
|
|
/// Entfernt alle Buttons aus Liste
|
|
/// </summary>
|
|
/// <param name="list"></param>
|
|
private void RemoveButtons(List<Button> list)
|
|
{
|
|
foreach (Button button in list)
|
|
{
|
|
panelButtons.Controls.Remove(button);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Einstellungen ändern
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void ButtonSettings_Click(object sender, EventArgs e)
|
|
{
|
|
Settings s = new Settings();
|
|
s.ShowDialog();
|
|
|
|
zielPath = Properties.Settings.Default.targetPath;
|
|
labelZielPath.Text = zielPath;
|
|
imageIndex = 0;
|
|
|
|
if (Properties.Settings.Default.fileAssociation)
|
|
{
|
|
ExtractAssocIcons();
|
|
FileAssociation.Add("Image_Sorter_JPG", ".jpg", Application.ExecutablePath, "JPG Bild", $@"{Application.StartupPath}\AssocIcons\jpg.ico");
|
|
FileAssociation.Add("Image_Sorter_PNG", ".png", Application.ExecutablePath, "PNG Bild", $@"{Application.StartupPath}\AssocIcons\png.ico");
|
|
FileAssociation.Add("Image_Sorter_GIF", ".gif", Application.ExecutablePath, "GIF Bild", $@"{Application.StartupPath}\AssocIcons\gif.ico");
|
|
FileAssociation.Add("Image_Sorter_JPEG", ".jpeg", Application.ExecutablePath, "JPEG Bild", $@"{Application.StartupPath}\AssocIcons\jpeg.ico");
|
|
FileAssociation.Add("Image_Sorter_BMP", ".bmp", Application.ExecutablePath, "BMP Bild", $@"{Application.StartupPath}\AssocIcons\bmp.ico");
|
|
FileAssociation.Add("Image_Sorter_TIF", ".tif", Application.ExecutablePath, "TIF Bild", $@"{Application.StartupPath}\AssocIcons\tif.ico");
|
|
FileAssociation.Add("Image_Sorter_TIFF", ".tiff", Application.ExecutablePath, "TIFF Bild", $@"{Application.StartupPath}\AssocIcons\tiff.ico");
|
|
FileAssociation.Add("Image_Sorter_WEBP", ".webp", Application.ExecutablePath, "WEBP Bild", $@"{Application.StartupPath}\AssocIcons\webp.ico");
|
|
FileAssociation.Add("Image_Sorter_HEIC", ".heic", Application.ExecutablePath, "HEIC Bild", $@"{Application.StartupPath}\AssocIcons\heic.ico");
|
|
}
|
|
else
|
|
{
|
|
if(Directory.Exists($@"{Application.StartupPath}\AssocIcons"))
|
|
{
|
|
Directory.Delete($@"{Application.StartupPath}\AssocIcons", true);
|
|
FileAssociation.Remove("Image_Sorter_JPG");
|
|
FileAssociation.Remove("Image_Sorter_PNG");
|
|
FileAssociation.Remove("Image_Sorter_GIF");
|
|
FileAssociation.Remove("Image_Sorter_JPEG");
|
|
FileAssociation.Remove("Image_Sorter_BMP");
|
|
FileAssociation.Remove("Image_Sorter_TIF");
|
|
FileAssociation.Remove("Image_Sorter_TIFF");
|
|
FileAssociation.Remove("Image_Sorter_WEBP");
|
|
FileAssociation.Remove("Image_Sorter_HEIC");
|
|
}
|
|
}
|
|
|
|
CheckSubfolders();
|
|
SearchImages();
|
|
CountPicsInPath();
|
|
ResetUndo();
|
|
|
|
panelImageBackground.BackColor = Properties.Settings.Default.lightBackgroundColour;
|
|
pictureBoxImage.BackColor = Properties.Settings.Default.lightBackgroundColour;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fügt alle Bilder des aktuellen Verzeichnisses der Liste hinzu
|
|
/// </summary>
|
|
private void SearchImages()
|
|
{
|
|
images.Clear();
|
|
|
|
foreach (string image in Directory.EnumerateFiles(quellPath, "*.*", System.IO.SearchOption.AllDirectories).Where(s => fileTypes.Any(ext => ext == Path.GetExtension(s).ToLower())))
|
|
{
|
|
images.Add(image);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gibt den Index des Bildes in der Bilderliste zurück
|
|
/// </summary>
|
|
/// <param name="image"></param>
|
|
/// <returns></returns>
|
|
private int GetImageIndex(string image)
|
|
{
|
|
int index = images.IndexOf(image);
|
|
return index;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Zählt die Bilddateien im Pfad
|
|
/// </summary>
|
|
private void CountPicsInPath()
|
|
{
|
|
Thread thread = new Thread(new ThreadStart(CountPicsInPathThread))
|
|
{
|
|
IsBackground = true
|
|
};
|
|
thread.Start();
|
|
}
|
|
|
|
private void CountPicsInPathThread()
|
|
{
|
|
Monitor.Enter(locker);
|
|
try
|
|
{
|
|
int counted = 0;
|
|
counted = images.Count();
|
|
Invoke(new dlgRefreshCounters(RefreshCounters), counted);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
}
|
|
finally
|
|
{
|
|
Monitor.Exit(locker);
|
|
}
|
|
}
|
|
|
|
public delegate void dlgRefreshCounters(int counted);
|
|
|
|
/// <summary>
|
|
/// aktualisiert die Zähler zur Bilderaktionsstatistik
|
|
/// </summary>
|
|
/// <param name="total"></param>
|
|
private void RefreshCounters(int total)
|
|
{
|
|
if (total == 0)
|
|
{
|
|
labelCounter.Text = "keine Bilder vorhanden";
|
|
SetButtonsEnabled(false);
|
|
}
|
|
else if (total == 1)
|
|
{
|
|
labelCounter.Text = "1 Bild gesamt";
|
|
SetButtonsEnabled(true);
|
|
}
|
|
else
|
|
{
|
|
labelCounter.Text = total.ToString() + " Bilder gesamt";
|
|
SetButtonsEnabled(true);
|
|
}
|
|
|
|
if (moved == 0)
|
|
{
|
|
labelCounter.Text += Environment.NewLine + "keines verschoben";
|
|
}
|
|
else
|
|
{
|
|
labelCounter.Text += Environment.NewLine + this.moved.ToString() + " bereits verschoben";
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Subdirectory-Ordner Buttons aktivieren/dekativieren
|
|
/// </summary>
|
|
/// <param name="enabled"></param>
|
|
private void SetButtonsEnabled(bool enabled)
|
|
{
|
|
foreach (Button b in buttons)
|
|
{
|
|
b.Enabled = enabled;
|
|
}
|
|
buttonDeleteImage.Enabled = enabled;
|
|
buttonMirrorHorizontal.Enabled = enabled;
|
|
buttonMirrorVertikal.Enabled = enabled;
|
|
buttonRotate180.Enabled = enabled;
|
|
buttonRotate270.Enabled = enabled;
|
|
buttonRotate90.Enabled = enabled;
|
|
comboBoxZoom.Enabled = enabled;
|
|
buttonJumpForward.Enabled = enabled;
|
|
labelNoImages.Visible = !enabled;
|
|
buttonDateirenamer.Enabled = enabled;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Lädt das Bild in die Picturebox
|
|
/// </summary>
|
|
/// <param name="index"></param>
|
|
private void LoadPicture(int index)
|
|
{
|
|
if (images.Count() > 0)
|
|
{
|
|
imageIndex = index;
|
|
if (imageIndex >= images.Count() || imageIndex < 0)
|
|
{
|
|
imageIndex = 0;
|
|
}
|
|
pictureBoxImage.ImageLocation = CropImageBorders(images.ElementAt(imageIndex));
|
|
string resolutionTitle = "";
|
|
//if(pictureBoxImage.Image != null)
|
|
//{
|
|
// resolutionTitle = " (" + pictureBoxImage.Image.Width + "px x " + pictureBoxImage.Image.Height + "px)";
|
|
//}
|
|
Text = defaultWindowName + " - " + Path.GetFileName(pictureBoxImage.ImageLocation) + resolutionTitle;
|
|
}
|
|
else
|
|
{
|
|
pictureBoxImage.Image = null;
|
|
Text = defaultWindowName;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Entfernt gleichfarbige Rahmen automatisch von Bildern
|
|
/// </summary>
|
|
/// <param name="imagepath"></param>
|
|
private string CropImageBorders(string imagepath)
|
|
{
|
|
try
|
|
{
|
|
Bitmap p = new Bitmap(imagepath);
|
|
Bitmap x = BorderCropper.CropUnwantedBackground(p);
|
|
p.Dispose();
|
|
if (x != null)
|
|
{
|
|
x.Save(imagepath);
|
|
Image myImg = CopyImage.GetCopyImage(imagepath);
|
|
ShowAutoBorderChopMessage(myImg, imagepath);
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
}
|
|
return imagepath;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Löscht die Undo-History
|
|
/// </summary>
|
|
private void ResetUndo()
|
|
{
|
|
history.Clear();
|
|
CheckUndo();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Prüft ob Undo möglich ist
|
|
/// </summary>
|
|
private void CheckUndo()
|
|
{
|
|
if (history.Count() > 0)
|
|
{
|
|
buttonUndo.Enabled = true;
|
|
}
|
|
else
|
|
{
|
|
buttonUndo.Enabled = false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verschiebt ein Bild in ein Unterverzeichnis
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void MovePicture(object sender, EventArgs e)
|
|
{
|
|
Button btn = (Button)sender;
|
|
string[] folderButton = btn.Text.Split('(');
|
|
int count = int.Parse(folderButton[1].Substring(0, folderButton[1].Length - 1)) + 1;
|
|
string targetPath = Path.Combine(zielPath, folderButton[0].Substring(0, folderButton[0].Length - 1));
|
|
|
|
try
|
|
{
|
|
string fullTargetPath = Path.Combine(targetPath, CleanFileName(Path.GetFileName(pictureBoxImage.ImageLocation)));
|
|
Image myImg = CopyImage.GetCopyImage(pictureBoxImage.ImageLocation);
|
|
if (File.Exists(fullTargetPath))
|
|
{
|
|
using (var form = new Vergleicher("Das zu verschiebende Bild \"" + CleanFileName(Path.GetFileName(pictureBoxImage.ImageLocation)) + "\"" + "existiert im Zielverzeichnis \"" + btn.Text + "\" bereits." + Environment.NewLine + Environment.NewLine + "Soll eine Kopie angelegt werden? Nein überschreibt die Datei, Abbrechen bricht den Vorgang ab.", pictureBoxImage.ImageLocation, fullTargetPath))
|
|
{
|
|
var result = form.ShowDialog();
|
|
if (result == DialogResult.Yes)
|
|
{
|
|
fullTargetPath = Path.Combine(targetPath, CleanFileName(Path.GetFileNameWithoutExtension(pictureBoxImage.ImageLocation)) + Randomize.NumbersAndDigits(5, "_") + Path.GetExtension(pictureBoxImage.ImageLocation));
|
|
}
|
|
else if (result == DialogResult.No)
|
|
{
|
|
File.Copy(pictureBoxImage.ImageLocation, fullTargetPath, true);
|
|
File.Delete(pictureBoxImage.ImageLocation);
|
|
images.Remove(pictureBoxImage.ImageLocation);
|
|
history.Add(fullTargetPath);
|
|
moved++;
|
|
ShowMovedMessage(myImg, fullTargetPath, btn.Text);
|
|
CheckSubfolders();
|
|
CountPicsInPath();
|
|
LoadPicture(imageIndex);
|
|
CheckUndo();
|
|
return;
|
|
}
|
|
else if (result == DialogResult.Cancel)
|
|
{
|
|
ImageDelete(null, null);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
File.Move(pictureBoxImage.ImageLocation, fullTargetPath);
|
|
images.Remove(pictureBoxImage.ImageLocation);
|
|
history.Add(fullTargetPath);
|
|
moved++;
|
|
ShowMovedMessage(myImg, fullTargetPath, btn.Text);
|
|
}
|
|
catch (IOException ex)
|
|
{
|
|
MessageBox.Show(ex.ToString());
|
|
}
|
|
|
|
btn.Text = folderButton[0] + "(" + count + ")";
|
|
CountPicsInPath();
|
|
LoadPicture(imageIndex);
|
|
CheckUndo();
|
|
ShowPreviewImages(false, true);
|
|
|
|
if (Properties.Settings.Default.fading)
|
|
{
|
|
btn.BackColor = Color.LightSalmon;
|
|
btn.ForeColor = Color.MediumSeaGreen;
|
|
btn.Font = new Font(btn.Font, FontStyle.Bold);
|
|
System.Timers.Timer t = new System.Timers.Timer(700);
|
|
t.Elapsed += new System.Timers.ElapsedEventHandler((sender1, e1) => ButtonBlink(sender, e, btn, t));
|
|
t.Start();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes the marks from cropping and cutting in filename
|
|
/// </summary>
|
|
/// <param name="filename"></param>
|
|
/// <returns></returns>
|
|
private string CleanFileName(string filename)
|
|
{
|
|
string fn = filename;
|
|
fn = fn.Replace("_crp", "");
|
|
fn = fn.Replace("_cut", "");
|
|
return fn;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Blinkender Button nach erfolgreichem Verschieben
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
/// <param name="btn"></param>
|
|
private void ButtonBlink(object sender, EventArgs e, Button btn, System.Timers.Timer t)
|
|
{
|
|
btn.BeginInvoke(new MethodInvoker(() =>
|
|
{
|
|
System.Timers.Timer tx = btn.Tag as System.Timers.Timer;
|
|
if (tx.Enabled)
|
|
{
|
|
tx.Stop();
|
|
btn.BackColor = Color.LightSalmon;
|
|
}
|
|
btn.ForeColor = SystemColors.ControlText;
|
|
btn.Font = new Font(btn.Font, FontStyle.Regular);
|
|
tx.Start();
|
|
}));
|
|
t.Stop();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hintergrundfarbe des Buttons langsam nach Transparent blenden
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
/// <param name="btn"></param>
|
|
private void ButtonFade(Button btn, System.Timers.Timer tx)
|
|
{
|
|
btn.BeginInvoke(new MethodInvoker(() =>
|
|
{
|
|
int speed = Properties.Settings.Default.fadingSpeed * (Properties.Settings.Default.fadingSpeed / 3) + 1;
|
|
int alpha = btn.BackColor.A;
|
|
if (alpha - speed >= 0)
|
|
{
|
|
btn.BackColor = Color.FromArgb(btn.BackColor.A - speed, btn.BackColor.R, btn.BackColor.G, btn.BackColor.B);
|
|
}
|
|
else
|
|
{
|
|
btn.BackColor = Color.Transparent;
|
|
tx.Stop();
|
|
}
|
|
}));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Macht die letzte Aktion rückgängig
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void ButtonUndo_Click(object sender, EventArgs e)
|
|
{
|
|
string targetPath = Path.Combine(this.quellPath, Path.GetFileName(history.ElementAt(history.Count() - 1)));
|
|
if (Path.GetFullPath(history.ElementAt(history.Count() - 1)).StartsWith("C:\\img-tmp"))
|
|
{
|
|
targetPath = pictureBoxImage.ImageLocation;
|
|
}
|
|
|
|
try
|
|
{
|
|
Image myImg = CopyImage.GetCopyImage(history.ElementAt(history.Count() - 1));
|
|
File.Copy(history.ElementAt(history.Count() - 1), targetPath, true);
|
|
File.Delete(history.ElementAt(history.Count() - 1));
|
|
history.Remove(history.ElementAt(history.Count() - 1));
|
|
images.Insert(imageIndex, targetPath);
|
|
moved--;
|
|
ShowUndoMessage(myImg, targetPath);
|
|
}
|
|
catch (IOException ex)
|
|
{
|
|
MessageBox.Show(ex.ToString());
|
|
}
|
|
|
|
CheckSubfolders();
|
|
CountPicsInPath();
|
|
LoadPicture(imageIndex);
|
|
CheckUndo();
|
|
ShowPreviewImages(true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Dreht das Bild und überschreibt es
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void ImageRotate(object sender, EventArgs e)
|
|
{
|
|
Button btn = (Button)sender;
|
|
string rotateString = btn.Tag.ToString();
|
|
int rotation = int.Parse(rotateString);
|
|
|
|
Image subject = Image.FromFile(images.ElementAt(imageIndex));
|
|
|
|
if (rotation == 90)
|
|
{
|
|
subject.RotateFlip(RotateFlipType.Rotate90FlipNone);
|
|
}
|
|
else if (rotation == 180)
|
|
{
|
|
subject.RotateFlip(RotateFlipType.Rotate180FlipNone);
|
|
}
|
|
else
|
|
{
|
|
subject.RotateFlip(RotateFlipType.Rotate270FlipNone);
|
|
}
|
|
|
|
string ext = Path.GetExtension(images.ElementAt(imageIndex));
|
|
if (ext == ".png")
|
|
{
|
|
subject.Save(images.ElementAt(imageIndex), ImageFormat.Png);
|
|
}
|
|
else if (ext == ".gif")
|
|
{
|
|
subject.Save(images.ElementAt(imageIndex), ImageFormat.Gif);
|
|
}
|
|
else
|
|
{
|
|
subject.Save(images.ElementAt(imageIndex), ImageFormat.Jpeg);
|
|
}
|
|
|
|
LoadPicture(imageIndex);
|
|
groupBoxTransformation.Visible = false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Spiegelt ein Bild und überschreibt es
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void ImageMirror(object sender, EventArgs e)
|
|
{
|
|
Button btn = (Button)sender;
|
|
string mirrorString = btn.Tag.ToString();
|
|
|
|
Image subject = Image.FromFile(images.ElementAt(imageIndex));
|
|
|
|
if (mirrorString == "x")
|
|
{
|
|
subject.RotateFlip(RotateFlipType.RotateNoneFlipX);
|
|
}
|
|
else
|
|
{
|
|
subject.RotateFlip(RotateFlipType.RotateNoneFlipY);
|
|
}
|
|
|
|
string ext = Path.GetExtension(images.ElementAt(imageIndex));
|
|
if (ext == ".png")
|
|
{
|
|
subject.Save(images.ElementAt(imageIndex), ImageFormat.Png);
|
|
}
|
|
else if (ext == ".gif")
|
|
{
|
|
subject.Save(images.ElementAt(imageIndex), ImageFormat.Gif);
|
|
}
|
|
else
|
|
{
|
|
subject.Save(images.ElementAt(imageIndex), ImageFormat.Jpeg);
|
|
}
|
|
|
|
LoadPicture(imageIndex);
|
|
groupBoxTransformation.Visible = false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verschiebt ein Bild in den Papierkorb
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void ImageDelete(object sender, EventArgs e)
|
|
{
|
|
Image myImg = CopyImage.GetCopyImage(pictureBoxImage.ImageLocation);
|
|
string pfad = Path.GetFileName(pictureBoxImage.ImageLocation);
|
|
FileSystem.DeleteFile(pictureBoxImage.ImageLocation, UIOption.OnlyErrorDialogs, RecycleOption.SendToRecycleBin, UICancelOption.DoNothing);
|
|
images.Remove(pictureBoxImage.ImageLocation);
|
|
|
|
CheckSubfolders();
|
|
CountPicsInPath();
|
|
LoadPicture(imageIndex);
|
|
ShowDeletedMessage(myImg, pfad);
|
|
ShowPreviewImages(false, true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Zoom-Optionen
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void Zoom()
|
|
{
|
|
string zoom = comboBoxZoom.SelectedItem.ToString();
|
|
|
|
if (zoom == "Original")
|
|
{
|
|
pictureBoxImage.SizeMode = PictureBoxSizeMode.Zoom;
|
|
pictureBoxImage.Size = new Size(pictureBoxImage.Image.Width, pictureBoxImage.Image.Height);
|
|
if (pictureBoxImage.Image.Width > panelImageBackground.Width) { pictureBoxImage.Left = (panelImageBackground.Width / 2) - (pictureBoxImage.Width / 2); } else { pictureBoxImage.Left = (panelImageBackground.Width / 2) - (pictureBoxImage.Image.Width / 2); }
|
|
if (pictureBoxImage.Image.Height > panelImageBackground.Height) { pictureBoxImage.Top = (panelImageBackground.Height / 2) - (pictureBoxImage.Height / 2); } else { pictureBoxImage.Top = (panelImageBackground.Height / 2) - (pictureBoxImage.Image.Height / 2); }
|
|
moveable = true;
|
|
}
|
|
else if (zoom == "Vollbild")
|
|
{
|
|
pictureBoxImage.SizeMode = PictureBoxSizeMode.Zoom;
|
|
pictureBoxImage.Size = new Size(panelImageBackground.Width, panelImageBackground.Height);
|
|
pictureBoxImage.Top = 0;
|
|
pictureBoxImage.Left = 0;
|
|
moveable = false;
|
|
}
|
|
else if (zoom == "Auto")
|
|
{
|
|
pictureBoxImage.SizeMode = PictureBoxSizeMode.Zoom;
|
|
if(pictureBoxImage.Image.Width>panelImageBackground.Width || pictureBoxImage.Image.Height>panelImageBackground.Height)
|
|
{
|
|
pictureBoxImage.Size = new Size(panelImageBackground.Width, panelImageBackground.Height);
|
|
pictureBoxImage.Top = 0;
|
|
pictureBoxImage.Left = 0;
|
|
moveable = false;
|
|
}
|
|
else
|
|
{
|
|
pictureBoxImage.Size = new Size(pictureBoxImage.Image.Width, pictureBoxImage.Image.Height);
|
|
if (pictureBoxImage.Image.Width > panelImageBackground.Width) { pictureBoxImage.Left = (panelImageBackground.Width / 2) - (pictureBoxImage.Width / 2); } else { pictureBoxImage.Left = (panelImageBackground.Width / 2) - (pictureBoxImage.Image.Width / 2); }
|
|
if (pictureBoxImage.Image.Height > panelImageBackground.Height) { pictureBoxImage.Top = (panelImageBackground.Height / 2) - (pictureBoxImage.Height / 2); } else { pictureBoxImage.Top = (panelImageBackground.Height / 2) - (pictureBoxImage.Image.Height / 2); }
|
|
moveable = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
|
|
xFaktor = pictureBoxImage.Width / (double)pictureBoxImage.Image.Width;
|
|
yFaktor = pictureBoxImage.Height / (double)pictureBoxImage.Image.Height;
|
|
labelZoom2.Text = "x" + Math.Round(yFaktor, 1);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Mausklicks in picturebox verwalten
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void PictureBox_MouseDown(object sender, MouseEventArgs e)
|
|
{
|
|
if (e.Button == MouseButtons.Left)
|
|
{
|
|
if (moveable)
|
|
{
|
|
moving = true;
|
|
startLocation = e.Location;
|
|
pictureBoxImage.Cursor = grabbingCursor;
|
|
}
|
|
else
|
|
{
|
|
pictureBoxImage.Cursor = Cursors.No;
|
|
}
|
|
}
|
|
if (e.Button == MouseButtons.Middle)
|
|
{
|
|
if (moveable)
|
|
{
|
|
pictureBoxImage.Top = (panelImageBackground.Height / 2) - (pictureBoxImage.Height / 2);
|
|
pictureBoxImage.Left = (panelImageBackground.Width / 2) - (pictureBoxImage.Width / 2);
|
|
}
|
|
else
|
|
{
|
|
pictureBoxImage.Cursor = Cursors.No;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Mausklicks in picturebox verwalten
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void PictureBox_MouseUp(object sender, MouseEventArgs e)
|
|
{
|
|
if (moveable && moving)
|
|
{
|
|
moving = false;
|
|
if (pictureBoxImage.Top > 0) { pictureBoxImage.Top = 0; }
|
|
if (pictureBoxImage.Top < -pictureBoxImage.Height + panelImageBackground.Height) { pictureBoxImage.Top = -pictureBoxImage.Height + panelImageBackground.Height; }
|
|
if (pictureBoxImage.Left > 0) { pictureBoxImage.Left = 0; }
|
|
if (pictureBoxImage.Left < -pictureBoxImage.Width + panelImageBackground.Width) { pictureBoxImage.Left = -pictureBoxImage.Width + panelImageBackground.Width; }
|
|
}
|
|
pictureBoxImage.Cursor = grabCursor;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Bildausschnitt verschieben
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void PictureBox_MouseMove(object sender, MouseEventArgs e)
|
|
{
|
|
if (moving)
|
|
{
|
|
if (pictureBoxImage.Top > 0) { pictureBoxImage.Top = 0; }
|
|
if (pictureBoxImage.Top < -pictureBoxImage.Height + panelImageBackground.Height) { pictureBoxImage.Top = -pictureBoxImage.Height + panelImageBackground.Height; }
|
|
if (pictureBoxImage.Left > 0) { pictureBoxImage.Left = 0; }
|
|
if (pictureBoxImage.Left < -pictureBoxImage.Width + panelImageBackground.Width) { pictureBoxImage.Left = -pictureBoxImage.Width + panelImageBackground.Width; }
|
|
pictureBoxImage.Top += e.Location.Y - startLocation.Y;
|
|
pictureBoxImage.Left += e.Location.X - startLocation.X;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Bild Zoom
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void ZoomInOut(object sender, MouseEventArgs e)
|
|
{
|
|
if (e.Delta != 0 && pictureBoxImage.Image != null)
|
|
{
|
|
double xstep = pictureBoxImage.Width * 0.01;
|
|
double ystep = pictureBoxImage.Height * 0.01;
|
|
if (xstep < 1.0) { xstep = 1.0; }
|
|
if (ystep < 1.0) { ystep = 1.0; }
|
|
|
|
int maxWidth = pictureBoxImage.Image.Width * 8;
|
|
int minWidth = pictureBoxImage.Image.Width / 8;
|
|
|
|
int newWidth = pictureBoxImage.Width - (pictureBoxImage.Width / (int)xstep * (e.Delta / 120));
|
|
int newHeight = pictureBoxImage.Height - (pictureBoxImage.Height / (int)xstep * (e.Delta / 120));
|
|
|
|
if (newWidth <= maxWidth && newWidth >= minWidth)
|
|
{
|
|
pictureBoxImage.Width = newWidth;
|
|
pictureBoxImage.Height = newHeight;
|
|
}
|
|
|
|
if (pictureBoxImage.Width > panelImageBackground.Width || pictureBoxImage.Height > panelImageBackground.Height)
|
|
{
|
|
moveable = true;
|
|
if (pictureBoxImage.Right < panelImageBackground.Width) { pictureBoxImage.Left += -pictureBoxImage.Right + panelImageBackground.Width; }
|
|
if (pictureBoxImage.Bottom < panelImageBackground.Height) { pictureBoxImage.Top += -pictureBoxImage.Bottom + panelImageBackground.Height; }
|
|
}
|
|
else
|
|
{
|
|
moveable = false;
|
|
pictureBoxImage.Top = (panelImageBackground.Height / 2) - (pictureBoxImage.Height / 2);
|
|
pictureBoxImage.Left = (panelImageBackground.Width / 2) - (pictureBoxImage.Width / 2);
|
|
}
|
|
|
|
xFaktor = pictureBoxImage.Width / (double)pictureBoxImage.Image.Width;
|
|
yFaktor = pictureBoxImage.Height / (double)pictureBoxImage.Image.Height;
|
|
labelZoom2.Text = "x" + Math.Round(yFaktor, 1);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Focus auf Panel1 bei MouseEnter in Picturebox
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void PictureBox_MouseEnter(object sender, EventArgs e)
|
|
{
|
|
panelImageBackground.Focus();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Focus auf Buttons bei MouseLeave von Picturebox
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void PictureBox_MouseLeave(object sender, EventArgs e)
|
|
{
|
|
groupBoxInformationen.Focus();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Bild in picturebox vollständig geladen
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void PictureBox_LoadCompleted(object sender, AsyncCompletedEventArgs e)
|
|
{
|
|
Zoom();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Maus-Fokus auf Panel2 bei MouseEnter
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void Panel2_MouseEnter(object sender, EventArgs e)
|
|
{
|
|
panelButtons.Focus();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Öffnet im Explorer den Ordner des Bildes und legt den Fokus auf das aktuelle Bild, wenn es existiert
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void ToolStripMenuItemOpenExplorer_Click(object sender, EventArgs e)
|
|
{
|
|
if (File.Exists(pictureBoxImage.ImageLocation))
|
|
{
|
|
Process.Start("explorer.exe", @"/select, " + pictureBoxImage.ImageLocation);
|
|
}
|
|
|
|
else if (Directory.Exists(Path.GetDirectoryName(pictureBoxImage.ImageLocation)))
|
|
{
|
|
Process.Start("explorer.exe", Path.GetDirectoryName(pictureBoxImage.ImageLocation));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Zeigt Details (Eigenschaften) zum aktuellen Bild an
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void ToolStripMenuItemImageDetails_Click(object sender, EventArgs e)
|
|
{
|
|
using (Image img = Image.FromFile(pictureBoxImage.ImageLocation))
|
|
{
|
|
FileInfo info = new FileInfo(pictureBoxImage.ImageLocation);
|
|
ImageFormat format = img.RawFormat;
|
|
MessageBox.Show("Dateiname: " + info.Name + Environment.NewLine +
|
|
"Pfad: " + info.DirectoryName + Environment.NewLine +
|
|
"Erstellt: " + info.CreationTime + Environment.NewLine +
|
|
"Geändert: " + info.LastWriteTime + Environment.NewLine +
|
|
"Bildformat: " + new ImageFormatConverter().ConvertToString(format) + Environment.NewLine +
|
|
"Abmessungen: " + img.Width + " x " + img.Height + Environment.NewLine +
|
|
"Breite: " + img.Width + " Px" + Environment.NewLine +
|
|
"Höhe: " + img.Height + " Px" + Environment.NewLine +
|
|
"Auflösung: " + Resolution.GetImageResolution(img) + Environment.NewLine +
|
|
"Größe: " + FileSize.GetFileSize(info.Length) + Environment.NewLine +
|
|
"Bittiefe: " + Image.GetPixelFormatSize(img.PixelFormat) + " bit", "Bildeigenschaften", MessageBoxButtons.OK);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Zeigt die EXIF-Daten vom aktuellen Bild an
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void ToolStripMenuItemShowEXIF_Click(object sender, EventArgs e)
|
|
{
|
|
using (Image img = Image.FromFile(pictureBoxImage.ImageLocation))
|
|
{
|
|
EXIF exif = new EXIF(img.PropertyItems);
|
|
exif.ShowDialog(this);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Öffnet Paint zum Bearbeiten des Bildes
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void ToolStripMenuItemEditImage_Click(object sender, EventArgs e)
|
|
{
|
|
FileInfo info = new FileInfo(pictureBoxImage.ImageLocation);
|
|
ProcessStartInfo pi = new ProcessStartInfo
|
|
{
|
|
FileName = ("mspaint.exe"),
|
|
UseShellExecute = false,
|
|
Arguments = "\"" + info.FullName + "\""
|
|
};
|
|
Process p = new Process
|
|
{
|
|
StartInfo = pi
|
|
};
|
|
p.Start();
|
|
p.WaitForExit();
|
|
LoadPicture(imageIndex);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Öffnet das Cropping-Form um Bilder zuzuschneiden
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void BildZuschneidenToolStripMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
Cropper cropper = new Cropper(pictureBoxImage.ImageLocation);
|
|
DialogResult result = cropper.ShowDialog(this);
|
|
if (result == DialogResult.OK)
|
|
{
|
|
string del = pictureBoxImage.ImageLocation;
|
|
images[imageIndex] = cropper.NewFileLocation;
|
|
LoadPicture(imageIndex);
|
|
FileSystem.DeleteFile(del, UIOption.OnlyErrorDialogs, RecycleOption.SendToRecycleBin, UICancelOption.DoNothing);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Größe, Position in Settings speichern vor dem Schließen
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void Main_FormClosing(object sender, FormClosingEventArgs e)
|
|
{
|
|
Properties.Settings.Default.lastPath = quellPath;
|
|
Properties.Settings.Default.lastWidth = Width;
|
|
Properties.Settings.Default.lastHeight = Height;
|
|
Properties.Settings.Default.lastTop = Top;
|
|
Properties.Settings.Default.lastLeft = Left;
|
|
Properties.Settings.Default.showInfo = groupBoxInformationen.Visible;
|
|
Properties.Settings.Default.fullScreen = WindowState == FormWindowState.Maximized;
|
|
Properties.Settings.Default.preview = panelPreview.Visible;
|
|
Properties.Settings.Default.Save();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Anzeige eines Banners bei verschobenem Bild
|
|
/// </summary>
|
|
/// <param name="bildpfad"></param>
|
|
/// <param name="ordnername"></param>
|
|
private void ShowMovedMessage(Image bild, string bildpfad, string ordnername)
|
|
{
|
|
banner.Enqueue("Bild \"" + Path.GetFileName(bildpfad) + "\" erfolgreich nach", "\"" + ordnername + "\" verschoben.", bild, Properties.Resources.move);
|
|
banner.ShowMessages();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Anzeige eines Banners bei gelöschtem Bild
|
|
/// </summary>
|
|
/// <param name="bild"></param>
|
|
/// <param name="bildname"></param>
|
|
private void ShowDeletedMessage(Image bild, string bildname)
|
|
{
|
|
banner.Enqueue("Bild \"" + bildname + "\" erfolgreich gelöscht.", "", bild, Properties.Resources.delete);
|
|
banner.ShowMessages();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Anzeige eines Banners bei rückgängig gemachter Aktion
|
|
/// </summary>
|
|
/// <param name="bildpfad"></param>
|
|
private void ShowUndoMessage(Image bild, string bildpfad)
|
|
{
|
|
banner.Enqueue("Bildaktion für \"" + Path.GetFileName(bildpfad) + "\" erfolgreich", "rückgängig gemacht.", bild, Properties.Resources.undo);
|
|
banner.ShowMessages();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Anzeige eines Banners bei automatischem zuschneiden der Ränder
|
|
/// </summary>
|
|
/// <param name="bildpfad"></param>
|
|
private void ShowAutoBorderChopMessage(Image bild, string bildpfad)
|
|
{
|
|
banner.Enqueue("Die Ränder für \"" + Path.GetFileName(bildpfad) + "\" wurden", "automatisch zugeschnitten.", bild, Properties.Resources.crop);
|
|
banner.ShowMessages();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Anzeige eines Banners bei erstelltem Duplikat
|
|
/// </summary>
|
|
/// <param name="bild"></param>
|
|
/// <param name="bildpfad"></param>
|
|
private void ShowDuplicatedMessage(Image bild, string bildpfad)
|
|
{
|
|
banner.Enqueue("Das Duplikat \"" + Path.GetFileName(bildpfad) + "\"", "wurde erstellt.", bild, Properties.Resources.duplicate);
|
|
banner.ShowMessages();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Bild wieder neu zentrieren und skalieren nach Größenänderung des Fensters
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void Main_Resize(object sender, EventArgs e)
|
|
{
|
|
if (WindowState != FormWindowState.Minimized)
|
|
{
|
|
lastState = WindowState;
|
|
}
|
|
try
|
|
{
|
|
Zoom();
|
|
}
|
|
catch (Exception)
|
|
{
|
|
}
|
|
|
|
if (panelPreview.Visible)
|
|
{
|
|
ShowPreviewImages();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Globale Tasten-Events
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void Main_KeyDown(object sender, KeyEventArgs e)
|
|
{
|
|
if (e.KeyCode == Keys.Delete)
|
|
{
|
|
buttonDeleteImage.PerformClick();
|
|
e.Handled = true;
|
|
}
|
|
|
|
if (!e.Control && (e.KeyCode == Keys.Left || e.KeyCode == Keys.Down))
|
|
{
|
|
CountPicsInPath();
|
|
LoadPicture(imageIndex - 1);
|
|
CheckUndo();
|
|
e.Handled = true;
|
|
}
|
|
|
|
if (!e.Control && (e.KeyCode == Keys.Right || e.KeyCode == Keys.Up))
|
|
{
|
|
CountPicsInPath();
|
|
LoadPicture(imageIndex + 1);
|
|
CheckUndo();
|
|
e.Handled = true;
|
|
}
|
|
|
|
if (e.KeyCode == Keys.F2)
|
|
{
|
|
toolStripMenuItemCropImage.PerformClick();
|
|
e.Handled = true;
|
|
}
|
|
|
|
if (e.KeyCode == Keys.F3)
|
|
{
|
|
toolStripMenuItemEditImage.PerformClick();
|
|
e.Handled = true;
|
|
}
|
|
|
|
if (e.KeyCode == Keys.F4)
|
|
{
|
|
toolStripMenuItemOpenExplorer.PerformClick();
|
|
e.Handled = true;
|
|
}
|
|
|
|
if (e.KeyCode == Keys.F5)
|
|
{
|
|
toolStripMenuItemImageDetails.PerformClick();
|
|
e.Handled = true;
|
|
}
|
|
|
|
if (e.KeyCode == Keys.F6)
|
|
{
|
|
toolStripMenuItemShowEXIF.PerformClick();
|
|
e.Handled = true;
|
|
}
|
|
|
|
if (e.KeyCode == Keys.F10)
|
|
{
|
|
buttonSettings.PerformClick();
|
|
e.Handled = true;
|
|
}
|
|
|
|
if (e.KeyCode == Keys.F12)
|
|
{
|
|
buttonDateirenamer.PerformClick();
|
|
e.Handled = true;
|
|
}
|
|
|
|
if (e.KeyCode == Keys.Back)
|
|
{
|
|
buttonUndo.PerformClick();
|
|
e.Handled = true;
|
|
}
|
|
|
|
if (e.KeyCode == Keys.H)
|
|
{
|
|
buttonHintergrund.PerformClick();
|
|
e.Handled = true;
|
|
}
|
|
|
|
if (e.KeyCode == Keys.I)
|
|
{
|
|
buttonInfo.PerformClick();
|
|
e.Handled = true;
|
|
}
|
|
|
|
if (e.KeyCode == Keys.R)
|
|
{
|
|
buttonRander.PerformClick();
|
|
e.Handled = true;
|
|
}
|
|
|
|
if (e.KeyCode == Keys.D)
|
|
{
|
|
buttonDuplicate.PerformClick();
|
|
e.Handled = true;
|
|
}
|
|
|
|
if (e.KeyCode == Keys.T)
|
|
{
|
|
buttonTransformation.PerformClick();
|
|
e.Handled = true;
|
|
}
|
|
|
|
if (e.KeyCode == Keys.Q)
|
|
{
|
|
buttonQuellPfad.PerformClick();
|
|
e.Handled = true;
|
|
}
|
|
|
|
if (e.KeyCode == Keys.D1)
|
|
{
|
|
if (groupBoxRander.Visible)
|
|
{
|
|
trackBarRander.Value = 1;
|
|
TrackBarRander_Scroll(sender, e);
|
|
e.Handled = true;
|
|
}
|
|
}
|
|
|
|
if (e.KeyCode == Keys.D2)
|
|
{
|
|
if (groupBoxRander.Visible)
|
|
{
|
|
trackBarRander.Value = 2;
|
|
TrackBarRander_Scroll(sender, e);
|
|
e.Handled = true;
|
|
}
|
|
}
|
|
|
|
if (e.KeyCode == Keys.D3)
|
|
{
|
|
if (groupBoxRander.Visible)
|
|
{
|
|
trackBarRander.Value = 3;
|
|
TrackBarRander_Scroll(sender, e);
|
|
e.Handled = true;
|
|
}
|
|
}
|
|
|
|
if (e.KeyCode == Keys.D4)
|
|
{
|
|
if (groupBoxRander.Visible)
|
|
{
|
|
trackBarRander.Value = 4;
|
|
TrackBarRander_Scroll(sender, e);
|
|
e.Handled = true;
|
|
}
|
|
}
|
|
|
|
if (e.KeyCode == Keys.D5)
|
|
{
|
|
if (groupBoxRander.Visible)
|
|
{
|
|
trackBarRander.Value = 5;
|
|
TrackBarRander_Scroll(sender, e);
|
|
e.Handled = true;
|
|
}
|
|
}
|
|
|
|
if (e.KeyCode == Keys.D6)
|
|
{
|
|
if (groupBoxRander.Visible)
|
|
{
|
|
trackBarRander.Value = 6;
|
|
TrackBarRander_Scroll(sender, e);
|
|
e.Handled = true;
|
|
}
|
|
}
|
|
|
|
if (e.KeyCode == Keys.D7)
|
|
{
|
|
if (groupBoxRander.Visible)
|
|
{
|
|
trackBarRander.Value = 7;
|
|
TrackBarRander_Scroll(sender, e);
|
|
e.Handled = true;
|
|
}
|
|
}
|
|
|
|
if (e.KeyCode == Keys.D8)
|
|
{
|
|
if (groupBoxRander.Visible)
|
|
{
|
|
trackBarRander.Value = 8;
|
|
TrackBarRander_Scroll(sender, e);
|
|
e.Handled = true;
|
|
}
|
|
}
|
|
|
|
if (e.KeyCode == Keys.D9)
|
|
{
|
|
if (groupBoxRander.Visible)
|
|
{
|
|
trackBarRander.Value = 9;
|
|
TrackBarRander_Scroll(sender, e);
|
|
e.Handled = true;
|
|
}
|
|
}
|
|
|
|
if (e.KeyCode == Keys.D0)
|
|
{
|
|
if (groupBoxRander.Visible)
|
|
{
|
|
trackBarRander.Value = 10;
|
|
TrackBarRander_Scroll(sender, e);
|
|
e.Handled = true;
|
|
}
|
|
}
|
|
|
|
if (e.Control && e.KeyCode == Keys.Left)
|
|
{
|
|
buttonRandLinks.PerformClick();
|
|
e.Handled = true;
|
|
}
|
|
|
|
if (e.Control && e.KeyCode == Keys.Right)
|
|
{
|
|
buttonRandRechts.PerformClick();
|
|
e.Handled = true;
|
|
}
|
|
|
|
if (e.Control && e.KeyCode == Keys.Up)
|
|
{
|
|
buttonRandOben.PerformClick();
|
|
e.Handled = true;
|
|
}
|
|
|
|
if (e.Control && e.KeyCode == Keys.Down)
|
|
{
|
|
buttonRandUnten.PerformClick();
|
|
e.Handled = true;
|
|
}
|
|
|
|
if (e.KeyCode==Keys.P)
|
|
{
|
|
buttonPreview.PerformClick();
|
|
e.Handled = true;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Quellpfad auswählen
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void ButtonQuellPfad_Click(object sender, EventArgs e)
|
|
{
|
|
DialogResult result = folderBrowserDialog.ShowDialog();
|
|
if (result == DialogResult.OK)
|
|
{
|
|
quellPath = folderBrowserDialog.SelectedPath;
|
|
labelQuellPath.Text = quellPath;
|
|
}
|
|
|
|
CheckSubfolders();
|
|
SearchImages();
|
|
CountPicsInPath();
|
|
LoadPicture(0);
|
|
ResetUndo();
|
|
ShowPreviewImages();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Zoom-Combobox geändert
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void ComboBoxZoom_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
Properties.Settings.Default.zoom = comboBoxZoom.SelectedIndex;
|
|
Properties.Settings.Default.Save();
|
|
|
|
if(pictureBoxImage.Image != null)
|
|
{
|
|
Zoom();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Zu vorherigem Bild springen
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void ButtonJumpBack_Click(object sender, MouseEventArgs e)
|
|
{
|
|
CountPicsInPath();
|
|
LoadPicture(imageIndex - 1);
|
|
CheckUndo();
|
|
ShowPreviewImages(true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Zu nächstem Bild springen
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void ButtonJumpForward_Click(object sender, MouseEventArgs e)
|
|
{
|
|
CountPicsInPath();
|
|
LoadPicture(imageIndex + 1);
|
|
CheckUndo();
|
|
ShowPreviewImages(false, true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Informationen ein-/ausblenden
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void ButtonInfo_Click(object sender, EventArgs e)
|
|
{
|
|
if(groupBoxInformationen.Visible)
|
|
{
|
|
//ausblenden
|
|
groupBoxInformationen.Visible = false;
|
|
groupBoxZiele.Location = new Point(groupBoxZiele.Location.X, 12);
|
|
groupBoxZiele.Height += 87;
|
|
}
|
|
else
|
|
{
|
|
//einblenden
|
|
groupBoxInformationen.Visible = true;
|
|
groupBoxZiele.Location = new Point(groupBoxZiele.Location.X, 99);
|
|
groupBoxZiele.Height -= 87;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Duplikat von aktuellem Bild erzeugen
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void ButtonDuplicate_Click(object sender, EventArgs e)
|
|
{
|
|
//aktuelles bild kopieren
|
|
string targetPath = Path.Combine(Path.GetDirectoryName(pictureBoxImage.ImageLocation), Path.GetFileNameWithoutExtension(pictureBoxImage.ImageLocation) + Randomize.NumbersAndDigits(5, "_") + Path.GetExtension(pictureBoxImage.ImageLocation));
|
|
File.Copy(pictureBoxImage.ImageLocation, targetPath, true);
|
|
|
|
//duplikat als nächstes bild in liste aufnehmen
|
|
images.Insert(imageIndex + 1, targetPath);
|
|
CountPicsInPath();
|
|
|
|
//duplikat-message anzeigen
|
|
Image myImg = CopyImage.GetCopyImage(targetPath);
|
|
ShowDuplicatedMessage(myImg, targetPath);
|
|
|
|
ShowPreviewImages(true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Untermenü für Transformation ein-/ausblenden
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void ButtonTransformation_Click(object sender, EventArgs e)
|
|
{
|
|
groupBoxTransformation.Visible = !groupBoxTransformation.Visible;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hintergrund hell/dunkel schalten
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void ButtonHintergrund_Click(object sender, EventArgs e)
|
|
{
|
|
if(panelImageBackground.BackColor==Properties.Settings.Default.darkBackgroundColour)
|
|
{
|
|
panelImageBackground.BackColor = Properties.Settings.Default.lightBackgroundColour;
|
|
pictureBoxImage.BackColor = Properties.Settings.Default.lightBackgroundColour;
|
|
}
|
|
else
|
|
{
|
|
panelImageBackground.BackColor = Properties.Settings.Default.darkBackgroundColour;
|
|
pictureBoxImage.BackColor = Properties.Settings.Default.darkBackgroundColour;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ränder schneiden Untermenü ein-/ausblenden
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void ButtonRander_Click(object sender, EventArgs e)
|
|
{
|
|
groupBoxRander.Visible = !groupBoxRander.Visible;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Rand von Bild schneiden
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void RandSchneiden_Click(object sender, EventArgs e)
|
|
{
|
|
Button btn = (Button)sender;
|
|
string cutString = btn.Tag.ToString();
|
|
Image im = pictureBoxImage.Image;
|
|
|
|
int move = trackBarRander.Value;
|
|
int x = 0, y = 0, width = im.Width, height = im.Height;
|
|
|
|
if (cutString == "links")
|
|
{
|
|
x += move;
|
|
width -= move;
|
|
}
|
|
else if (cutString == "rechts")
|
|
{
|
|
width -= move;
|
|
}
|
|
else if (cutString == "oben")
|
|
{
|
|
y += move;
|
|
height -= move;
|
|
}
|
|
else if (cutString == "unten")
|
|
{
|
|
height -= move;
|
|
}
|
|
else if (cutString == "linksrechts")
|
|
{
|
|
x += move;
|
|
width -= move;
|
|
width -= move;
|
|
}
|
|
else if (cutString == "obenunten")
|
|
{
|
|
y += move;
|
|
height -= move;
|
|
height -= move;
|
|
}
|
|
else if (cutString == "alle")
|
|
{
|
|
x += move;
|
|
width -= move;
|
|
width -= move;
|
|
y += move;
|
|
height -= move;
|
|
height -= move;
|
|
}
|
|
|
|
Rectangle r = new Rectangle(x, y, width, height);
|
|
Image res = CropImage(im, r);
|
|
|
|
string folder = Path.GetDirectoryName(pictureBoxImage.ImageLocation);
|
|
string file = Path.GetFileNameWithoutExtension(pictureBoxImage.ImageLocation) + "_cut";
|
|
string ext = Path.GetExtension(pictureBoxImage.ImageLocation);
|
|
string newFileLocation = Path.Combine(folder, file + ext);
|
|
string del = pictureBoxImage.ImageLocation;
|
|
if (ext == ".png")
|
|
{
|
|
res.Save(newFileLocation, ImageFormat.Png);
|
|
}
|
|
else if (ext == ".gif")
|
|
{
|
|
res.Save(newFileLocation, ImageFormat.Gif);
|
|
}
|
|
else
|
|
{
|
|
res.Save(newFileLocation, ImageFormat.Jpeg);
|
|
}
|
|
images[imageIndex] = newFileLocation;
|
|
LoadPicture(imageIndex);
|
|
FileSystem.DeleteFile(del, UIOption.OnlyErrorDialogs, RecycleOption.SendToRecycleBin, UICancelOption.DoNothing);
|
|
|
|
groupBoxRander.Visible = false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// schneidet Bilder aus
|
|
/// </summary>
|
|
/// <param name="img"></param>
|
|
/// <param name="cropArea"></param>
|
|
/// <returns></returns>
|
|
private static Image CropImage(Image img, Rectangle cropArea)
|
|
{
|
|
Bitmap bmpImage = new Bitmap(img);
|
|
Bitmap bmpCrop = bmpImage.Clone(cropArea,
|
|
bmpImage.PixelFormat);
|
|
return (Image)(bmpCrop);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ändert das Pixel-Label auf den aktuellen Wert
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void TrackBarRander_Scroll(object sender, EventArgs e)
|
|
{
|
|
labelRander.Text = trackBarRander.Value + " px.";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Öffnet den Dateirenamer
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void ButtonDateirenamer_Click(object sender, EventArgs e)
|
|
{
|
|
Dateirenamer dr = new Dateirenamer(quellPath);
|
|
dr.ShowDialog(this);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Preview-Sektion anzeigen/ausblenden
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void ButtonPreview_Click(object sender, EventArgs e)
|
|
{
|
|
if (panelPreview.Visible)
|
|
{
|
|
panelImageBackground.Height += 100;
|
|
panelPreview.Visible = false;
|
|
}
|
|
else
|
|
{
|
|
panelImageBackground.Height -= 100;
|
|
ShowPreviewImages();
|
|
panelPreview.Visible = true;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Bildvorschau erzeugen und laden
|
|
/// </summary>
|
|
private void ShowPreviewImages(bool left = false, bool right = false)
|
|
{
|
|
try
|
|
{
|
|
int panelWidthAvailable = panelPreview.Width - 11; //verfügbare breite abzüglich ränder links+rechts
|
|
int previewImageWidth = 80; //breite eines preview-bildes
|
|
int previewImageAbstand = 11; //abstand zwischen preview-bildern
|
|
int previewBildmitAbstand = previewImageWidth + previewImageAbstand; //breite eines preview-bildes plus abstand
|
|
int previewNumber = panelWidthAvailable / previewBildmitAbstand; //anzahl der möglichen preview-bilder
|
|
int bildAbstand = (panelPreview.Width - 22 - (previewNumber * previewImageWidth)) / previewNumber; //errechneter Bildabstand für bessere verteilung
|
|
|
|
if (left)
|
|
{
|
|
//links neues bild laden
|
|
//rechte pb entfernen
|
|
panelPreview.Controls.Remove(panelPreview.Controls.OfType<PictureBox>().Last());
|
|
int newPbX = panelPreview.Controls.OfType<PictureBox>().First().Location.X;
|
|
//alle nach rechts verschieben
|
|
foreach (PictureBox pb in panelPreview.Controls.OfType<PictureBox>())
|
|
{
|
|
pb.Location = new Point(pb.Location.X + bildAbstand + previewImageWidth, pb.Location.Y);
|
|
}
|
|
//links neue pb erstellen
|
|
int pIndex = imageIndex;
|
|
pIndex += 1;
|
|
if (pIndex >= images.Count() || pIndex < 0)
|
|
{
|
|
pIndex = 0;
|
|
}
|
|
PictureBox pbn = new PictureBox
|
|
{
|
|
Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left,
|
|
BackgroundImageLayout = ImageLayout.Stretch,
|
|
BorderStyle = BorderStyle.None,
|
|
Location = new Point(newPbX, previewImageAbstand),
|
|
Size = new Size(previewImageWidth, previewImageWidth),
|
|
TabIndex = 0,
|
|
TabStop = false,
|
|
SizeMode = PictureBoxSizeMode.Zoom,
|
|
ImageLocation = images.ElementAt(pIndex),
|
|
Tag = pIndex
|
|
};
|
|
panelPreview.SuspendLayout();
|
|
panelPreview.Controls.Add(pbn);
|
|
panelPreview.Controls.SetChildIndex(pbn, 0);
|
|
panelPreview.ResumeLayout();
|
|
pbn.Click += new EventHandler(LoadPictureFromPreview_Click);
|
|
}
|
|
else if (right)
|
|
{
|
|
//rechts neues bild laden
|
|
//linke pb entfernen
|
|
panelPreview.Controls.Remove(panelPreview.Controls.OfType<PictureBox>().First());
|
|
int newPbX = panelPreview.Controls.OfType<PictureBox>().Last().Location.X;
|
|
//alle nach links verschieben
|
|
foreach (PictureBox pb in panelPreview.Controls.OfType<PictureBox>())
|
|
{
|
|
pb.Location = new Point(pb.Location.X - bildAbstand - previewImageWidth, pb.Location.Y);
|
|
}
|
|
//rechts neue pb erstellen
|
|
int pIndex = imageIndex;
|
|
pIndex += previewNumber + 1;
|
|
if (pIndex >= images.Count() || pIndex < 0)
|
|
{
|
|
pIndex = 0;
|
|
}
|
|
PictureBox pbn = new PictureBox
|
|
{
|
|
Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left,
|
|
BackgroundImageLayout = ImageLayout.Stretch,
|
|
BorderStyle = BorderStyle.None,
|
|
Location = new Point(newPbX, previewImageAbstand),
|
|
Size = new Size(previewImageWidth, previewImageWidth),
|
|
TabIndex = 0,
|
|
TabStop = false,
|
|
SizeMode = PictureBoxSizeMode.Zoom,
|
|
ImageLocation = images.ElementAt(pIndex),
|
|
Tag = pIndex
|
|
};
|
|
panelPreview.Controls.Add(pbn);
|
|
pbn.Click += new EventHandler(LoadPictureFromPreview_Click);
|
|
}
|
|
else
|
|
{
|
|
panelPreview.Controls.Clear();
|
|
for (int i = 1; i <= previewNumber; i++)
|
|
{
|
|
int moveNext = (i * previewImageWidth) + (bildAbstand * i) - 80;
|
|
PictureBox pb = new PictureBox
|
|
{
|
|
Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left,
|
|
BackgroundImage = Resources.no_picture,
|
|
BackgroundImageLayout = ImageLayout.Stretch,
|
|
BorderStyle = BorderStyle.None,
|
|
Location = new Point(moveNext, previewImageAbstand),
|
|
Name = "pictureBoxPreview" + i,
|
|
Size = new Size(previewImageWidth, previewImageWidth),
|
|
TabIndex = 0,
|
|
TabStop = false,
|
|
SizeMode = PictureBoxSizeMode.Zoom
|
|
};
|
|
panelPreview.Controls.Add(pb);
|
|
}
|
|
int pIndex = imageIndex;
|
|
foreach (PictureBox pb in panelPreview.Controls.OfType<PictureBox>())
|
|
{
|
|
//preview laden
|
|
if (images.Count() > pIndex)
|
|
{
|
|
pIndex += 1;
|
|
if (pIndex >= images.Count() || pIndex < 0)
|
|
{
|
|
pIndex = 0;
|
|
}
|
|
pb.ImageLocation = images.ElementAt(pIndex);
|
|
pb.BackgroundImage = null;
|
|
pb.Tag = pIndex;
|
|
pb.Click += new EventHandler(LoadPictureFromPreview_Click);
|
|
}
|
|
else
|
|
{
|
|
pb.BackgroundImage = Resources.no_picture;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Lädt Bilder, die in Vorschau angeklickt wurden
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void LoadPictureFromPreview_Click(object sender, EventArgs e)
|
|
{
|
|
var pb = (PictureBox)sender;
|
|
LoadPicture((int)pb.Tag);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Öffnet Seite zum Spenden
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void ButtonHeart_Click(object sender, EventArgs e)
|
|
{
|
|
Process.Start("https://www.kmpr.at/donate.php");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Öffnet Seite für Weihnachten
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void ButtonChristmas_Click(object sender, EventArgs e)
|
|
{
|
|
Process.Start("https://www.kmpr.at/christmas.php");
|
|
}
|
|
}
|
|
} |