Switch-Toolbox/Toolbox/MainForm.cs

1441 lines
49 KiB
C#

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading;
using System.Windows.Forms;
using Toolbox.Library.IO;
using Toolbox.Library;
using Toolbox.Library.Forms;
using System.IO;
using System.Runtime.InteropServices;
using System.Reflection;
using OpenTK.Graphics.OpenGL;
using Toolbox.Library.NodeWrappers;
using Toolbox.Library.Rendering;
using Toolbox.Library.Forms;
namespace Toolbox
{
public partial class MainForm : Form, IMdiContainer, IUpdateForm, IMainForm
{
private static MainForm _instance;
public static MainForm Instance { get { return _instance == null ? _instance = new MainForm() : _instance; } }
IFileFormat[] SupportedFormats;
IFileMenuExtension[] FileMenuExtensions;
public void AddChildContainer(Form form)
{
TabDupeIndex = 0;
form.Text = CheckTabDupes(form.Text);
form.MdiParent = this;
form.Show();
IFileFormat activeFile;
if (form is ObjectEditor)
activeFile = ((ObjectEditor)form).GetActiveFile();
else
activeFile = GetActiveIFileFormat();
if (activeFile != null)
SetFormatSettings(activeFile);
}
public MainForm()
{
InitializeComponent();
}
public void UpdateForm()
{
if (ActiveMdiChild is ObjectEditor)
{
var activeFile = ((ObjectEditor)ActiveMdiChild).GetActiveFile();
SetFormatSettings(activeFile);
}
}
//Use for files opened with program
public List<string> OpenedFiles = new List<string>();
private void Form1_Load(object sender, EventArgs e)
{
Runtime.MainForm = this;
compressionToolStripMenuItem.DropDownItems.AddRange(CompressionMenus.GetMenuItems().ToArray());
//Redo setting this since designer keeps resetting this
tabForms.myBackColor = FormThemes.BaseTheme.FormBackColor;
OnMdiWindowClosed();
ResetMenus();
bool HasVersionFile = true;
VersionCheck version = new VersionCheck(HasVersionFile);
if (HasVersionFile)
{
Runtime.ProgramVersion = version.ProgramVersion;
Runtime.CommitInfo = version.CommitInfo;
Runtime.CompileDate = version.CompileDate;
}
else
{
version.SaveVersionInfo();
}
ThreadStart t = new ThreadStart(UpdateProgram.CheckLatest);
Thread thread = new Thread(t);
thread.Start();
Application.Idle += Application_Idle;
if (Runtime.UseOpenGL)
{
ShaderTools.executableDir = Runtime.ExecutableDir;
OpenTKSharedResources.InitializeSharedResources();
if (OpenTKSharedResources.SetupStatus == OpenTKSharedResources.SharedResourceStatus.Initialized)
{
Runtime.OpenTKInitialized = true;
Runtime.renderer = GL.GetString(StringName.Renderer);
Runtime.openGLVersion = GL.GetString(StringName.Version);
Runtime.GLSLVersion = GL.GetString(StringName.ShadingLanguageVersion);
ParseGLVersion();
}
}
LoadPLugins();
UpdateToolbar(HasVersionFile);
LoadMDITheme();
LoadRecentList();
ReloadFiles();
LoadPluginFileContextMenus();
WindowsExplorer.ExplorerContextMenu.LoadMenus();
foreach (string file in OpenedFiles)
{
if (File.Exists(file))
OpenFile(file);
}
OpenedFiles.Clear();
if (Runtime.UseDebugDomainExceptionHandler)
{
AppDomain currentDomain = AppDomain.CurrentDomain;
currentDomain.UnhandledException += new UnhandledExceptionEventHandler(MyHandler);
}
}
public void OpenFiles()
{
foreach (string file in OpenedFiles)
{
if (File.Exists(file))
OpenFile(file);
}
OpenedFiles.Clear();
}
private void ReloadFiles()
{
SupportedFormats = FileManager.GetFileFormats();
FileMenuExtensions = FileManager.GetMenuExtensions();
}
static void MyHandler(object sender, UnhandledExceptionEventArgs args)
{
Exception e = (Exception)args.ExceptionObject;
MessageBox.Show("MyHandler caught : " + e.Message);
MessageBox.Show("Runtime terminating: {0}", args.IsTerminating.ToString());
}
private void ParseGLVersion()
{
char[] Version = Runtime.openGLVersion.ToCharArray();
char Major = Version[0];
char Minor = Version[2];
char Minor2 = Version[4];
int major;
if (int.TryParse(Version[0].ToString(), out major))
{
if (major <= 2)
{
Runtime.UseLegacyGL = true;
}
if (major <= 1)
{
Runtime.UseOpenGL = false;
}
}
}
#region Updater
bool UsePrompt = true;
private void Application_Idle(object sender, EventArgs e)
{
if (UpdateProgram.CanUpdate && Runtime.EnableVersionCheck && UsePrompt &&
UpdateProgram.CommitList.Count > 0)
{
updateToolstrip.Enabled = true;
}
}
private void UpdateNotifcationClick()
{
if (UpdateProgram.CommitList.Count <= 0)
return;
var dialog = new GithubUpdateDialog();
dialog.LoadCommits(UpdateProgram.CommitList);
if (dialog.ShowDialog() == DialogResult.Yes)
{
UpdateApplication();
}
}
private void UpdateApplication()
{
//Start updating while program is closed
Process proc = new Process();
proc.StartInfo.FileName = Path.Combine(Runtime.ExecutableDir, "Updater.exe");
proc.StartInfo.WorkingDirectory = Runtime.ExecutableDir;
proc.StartInfo.CreateNoWindow = false;
proc.StartInfo.Arguments = "-d -i -b";
proc.StartInfo.WindowStyle = ProcessWindowStyle.Normal;
proc.Start();
Environment.Exit(0);
}
#endregion
#region OpenFile
private void openToolStripMenuItem_Click(object sender, EventArgs e) {
OpenFileSelect();
}
private void openFolderToolStripMenuItem_Click(object sender, EventArgs e) {
FolderSelectDialog dlg = new FolderSelectDialog();
if (dlg.ShowDialog() == DialogResult.OK)
{
var root = new ExplorerFolder(dlg.SelectedPath);
ObjectEditor editor = new ObjectEditor();
editor.MdiParent = this;
editor.Text = CheckTabDupes(root.Text);
editor.AddNode(root);
editor.Show();
}
}
private void OpenFileSelect()
{
OpenFileDialog ofd = new OpenFileDialog();
ofd.Filter = Utils.GetAllFilters(SupportedFormats);
ofd.Multiselect = true;
if (ofd.ShowDialog() == DialogResult.OK)
{
Cursor.Current = Cursors.WaitCursor;
foreach (string file in ofd.FileNames)
OpenFile(file);
Cursor.Current = Cursors.Default;
}
}
private void openActiveFileToolStripMenuItem_Click(object sender, EventArgs e)
{
OpenFileDialog ofd = new OpenFileDialog();
ofd.Filter = Utils.GetAllFilters(SupportedFormats);
ofd.Multiselect = true;
if (ofd.ShowDialog() == DialogResult.OK)
{
Cursor.Current = Cursors.WaitCursor;
foreach (string file in ofd.FileNames)
OpenFile(file, true);
Cursor.Current = Cursors.Default;
}
}
public void OpenFile(string FileName, bool InActiveEditor = false)
{
if (File.Exists(FileName))
SaveRecentFile(FileName);
object file = STFileLoader.OpenFileFormat(FileName);
if (file == null) //File might not be supported so return
return;
Type objectType = file.GetType();
bool HasEditorActive = false;
foreach (var inter in objectType.GetInterfaces())
{
if (inter.IsGenericType && inter.GetGenericTypeDefinition() == typeof(IEditor<>))
{
MethodInfo method = objectType.GetMethod("OpenForm");
MethodInfo methodFill = objectType.GetMethod("FillEditor");
var control = (UserControl)method.Invoke(file, new object[0]);
methodFill.Invoke(file, new object[1] { control });
var form = new GenericEditorForm(false, control);
TabDupeIndex = 0;
form.Text = CheckTabDupes(((IFileFormat)file).FileName);
form.MdiParent = this;
form.Show();
HasEditorActive = true;
}
else if (inter.IsGenericType && inter.GetGenericTypeDefinition() == typeof(IEditorForm<>))
{
MethodInfo method = objectType.GetMethod("OpenForm");
var form = (Form)method.Invoke(file, new object[0]);
TabDupeIndex = 0;
form.Text = CheckTabDupes(((IFileFormat)file).FileName);
form.Show();
HasEditorActive = true;
}
}
bool IsTreeNode = file is TreeNode;
bool IsArchiveFile = file is IArchiveFile;
if (!IsTreeNode && !IsArchiveFile || HasEditorActive)
{
SetFormatSettings(GetActiveIFileFormat());
return;
}
//ObjectEditor is for treenode or archive file types. Editors will be on the right side, treenodes on the left
SetFormatSettings((IFileFormat)file);
//Check for active object editors
Form editor = (Form)LibraryGUI.GetActiveForm();
bool useActiveEditor = false;
if (editor != null && editor is ObjectEditor)
{
//If any are active and we want it to be a new tab then create an instance of one
if (InActiveEditor || ((ObjectEditor)editor).AddFilesToActiveEditor)
{
useActiveEditor = true;
}
}
bool IsEditorActive = editor != null;
if (!useActiveEditor || !IsEditorActive)
{
editor = new ObjectEditor(((IFileFormat)file));
editor.MdiParent = this;
editor.Text = CheckTabDupes(((IFileFormat)file).FileName);
editor.Show();
((ObjectEditor)editor).SelectFirstNode();
}
else
{
if (IsArchiveFile)
((ObjectEditor)editor).AddIArchiveFile((IFileFormat)file);
else
AddObjectEditorFile(((TreeNode)file), (ObjectEditor)editor, false);
}
SetFormatSettings(GetActiveIFileFormat());
if (file is TreeNodeFile)
((TreeNodeFile)file).OnAfterAdded();
}
private void AddObjectEditorFile(TreeNode file, ObjectEditor editor, bool ClearFiles)
{
TabDupeIndex = 0;
editor.MdiParent = this;
editor.AddNode(file, ClearFiles);
editor.SelectNode(file);
if (file is TreeNodeFile)
{
((TreeNodeFile)file).OnAfterAdded();
}
}
#endregion
#region SaveFile
public void SaveActiveFile(bool UseSaveDialog = true, bool UseCompressDialog = true)
{
if (ActiveMdiChild != null)
{
if (ActiveMdiChild is ObjectEditor)
SaveNodeFormats((ObjectEditor)ActiveMdiChild, UseSaveDialog, UseCompressDialog);
else
{
var format = GetActiveIFileFormat();
if (!format.CanSave)
return;
string FileName = format.FilePath;
if (!File.Exists(FileName))
UseSaveDialog = true;
if (UseSaveDialog)
{
if (format is VGAdudioFile)
{
SaveFileDialog sfd = new SaveFileDialog();
List<IFileFormat> formats = new List<IFileFormat>();
foreach (VGAdudioFile fileFormat in FileManager.GetVGAudioFileFormats())
{
formats.Add((IFileFormat)fileFormat);
}
sfd.Filter = Utils.GetAllFilters(formats);
if (sfd.ShowDialog() != DialogResult.OK)
return;
foreach (var fileFormat in formats)
{
foreach (var ext in format.Extension)
{
if (Utils.HasExtension(sfd.FileName, ext))
{
((VGAdudioFile)format).Format = fileFormat;
}
}
}
FileName = sfd.FileName;
}
else
{
SaveFileDialog sfd = new SaveFileDialog();
sfd.Filter = Utils.GetAllFilters(format);
sfd.FileName = format.FileName;
if (sfd.ShowDialog() != DialogResult.OK)
return;
FileName = sfd.FileName;
}
}
Cursor.Current = Cursors.WaitCursor;
STFileSaver.SaveFileFormat(format, FileName, UseCompressDialog);
Cursor.Current = Cursors.Default;
}
}
}
private void SaveNodeFormats(ObjectEditor editor, bool UseSaveDialog, bool UseCompressDialog)
{
foreach (var node in editor.GetNodes())
{
IFileFormat format = null;
if (node is ArchiveBase)
{
format = (IFileFormat)((ArchiveBase)node).ArchiveFile;
if (node is ArchiveRootNodeWrapper)
((ArchiveRootNodeWrapper)node).UpdateFileNames();
}
else if (node is IFileFormat)
{
format = ((IFileFormat)node);
}
if (format != null)
{
if (!format.CanSave)
return;
string FileName = format.FilePath;
if (!File.Exists(FileName))
UseSaveDialog = true;
if (UseSaveDialog)
{
SaveFileDialog sfd = new SaveFileDialog();
sfd.Filter = Utils.GetAllFilters(format);
sfd.FileName = format.FileName;
if (sfd.ShowDialog() != DialogResult.OK)
return;
FileName = sfd.FileName;
}
Cursor.Current = Cursors.WaitCursor;
//Use the export method for particular formats like bfres for special save operations
if (format is STGenericWrapper && !(format is STGenericTexture))
{
((STGenericWrapper)format).Export(FileName);
return;
}
if (node is ArchiveBase)
STFileSaver.SaveFileFormat(((IFileFormat)((ArchiveBase)node).ArchiveFile), FileName, UseCompressDialog);
else
STFileSaver.SaveFileFormat(((IFileFormat)node), FileName, UseCompressDialog);
Cursor.Current = Cursors.Default;
}
}
}
#endregion
#region Recent Files
List<string> RecentFiles = new List<string>();
int TabDupeIndex = 0;
private string CheckTabDupes(string Name)
{
foreach (TabPage tab in tabForms.TabPages)
{
if (tab.Text == Name)
{
Name = Name + TabDupeIndex++;
return CheckTabDupes(Name);
}
}
return Name;
}
const int MRUnumber = 6;
private void SaveRecentFile(string path)
{
recentToolStripMenuItem.DropDownItems.Clear();
LoadRecentList(); //load list from file
if (!(RecentFiles.Contains(path))) //prevent duplication on recent list
RecentFiles.Insert(0, path); //insert given path into list
//keep list number not exceeded the given value
while (RecentFiles.Count > MRUnumber)
{
RecentFiles.RemoveAt(MRUnumber);
}
foreach (string item in RecentFiles)
{
//create new menu for each item in list
STToolStripItem fileRecent = new STToolStripItem();
fileRecent.Click += RecentFile_click;
fileRecent.Text = item;
fileRecent.Size = new System.Drawing.Size(170, 40);
fileRecent.AutoSize = true;
fileRecent.Image = null;
//add the menu to "recent" menu
recentToolStripMenuItem.DropDownItems.Add(fileRecent);
}
//writing menu list to file
//create file called "Recent.txt" located on app folder
StreamWriter stringToWrite =
new StreamWriter(Runtime.ExecutableDir + "\\Recent.txt");
foreach (string item in RecentFiles)
{
stringToWrite.WriteLine(item); //write list to stream
}
stringToWrite.Flush(); //write stream to file
stringToWrite.Close(); //close the stream and reclaim memory
}
private void LoadRecentList()
{//try to load file. If file isn't found, do nothing
RecentFiles.Clear();
if (File.Exists(Runtime.ExecutableDir + "\\Recent.txt"))
{
StreamReader listToRead = new StreamReader(Runtime.ExecutableDir + "\\Recent.txt"); //read file stream
string line;
while ((line = listToRead.ReadLine()) != null) //read each line until end of file
{
if (File.Exists(line))
RecentFiles.Add(line); //insert to list
}
listToRead.Close(); //close the stream
}
foreach (string item in RecentFiles)
{
STToolStripItem fileRecent = new STToolStripItem();
fileRecent.Click += RecentFile_click;
fileRecent.Text = item;
fileRecent.Size = new System.Drawing.Size(170, 40);
fileRecent.AutoSize = true;
fileRecent.Image = null;
recentToolStripMenuItem.DropDownItems.Add(fileRecent); //add the menu to "recent" menu
}
}
private void RecentFile_click(object sender, EventArgs e)
{
Cursor.Current = Cursors.WaitCursor;
OpenFile(sender.ToString());
Cursor.Current = Cursors.Default;
}
#endregion
#region Form Settings and plugin menus
public static void LoadConfig()
{
try
{
Config.StartupFromFile(Runtime.ExecutableDir + "\\config.xml");
Config.GamePathsFromFile(Runtime.ExecutableDir + "\\config_paths.xml");
}
catch (Exception ex)
{
MessageBox.Show($"Failed to load config file! {ex}");
}
}
private void UpdateToolbar(bool DisplayVersion)
{
string commit = $"Commit: {Runtime.CommitInfo}";
if (DisplayVersion)
Text = $"{Application.ProductName} | Version: {Runtime.ProgramVersion} | {commit} | Compile Date: {Runtime.CompileDate}";
else
Text = $"{Application.ProductName}";
}
private void LoadPLugins()
{
GenericPluginLoader.LoadPlugin();
foreach (var plugin in GenericPluginLoader._Plugins)
{
plugin.Value.Load();
LoadPluginContextMenus(plugin.Value.Types);
}
}
private List<IMenuExtension> menuExtentions = new List<IMenuExtension>();
private void LoadPluginContextMenus(Type[] types)
{
foreach (Type T in types)
{
Type[] interfaces_array = T.GetInterfaces();
for (int i = 0; i < interfaces_array.Length; i++)
{
if (interfaces_array[i] == typeof(IMenuExtension))
{
menuExtentions.Add((IMenuExtension)Activator.CreateInstance(T));
}
}
}
foreach (IMenuExtension ext in menuExtentions)
{
if (ext.FileMenuExtensions != null)
RegisterMenuExtIndex(fileToolStripMenuItem, ext.FileMenuExtensions, fileToolStripMenuItem.DropDownItems.Count); //last items are separator and settings
if (ext.ToolsMenuExtensions != null)
RegisterMenuExtIndex(toolsToolStripMenuItem, ext.ToolsMenuExtensions);
if (ext.TitleBarExtensions != null)
RegisterMenuExtIndex(menuStrip1, ext.TitleBarExtensions, menuStrip1.Items.Count);
}
}
private void LoadPluginFileContextMenus()
{
foreach (IFileMenuExtension ext in FileMenuExtensions)
{
if (ext.NewFileMenuExtensions != null)
RegisterMenuExtIndex(newToolStripMenuItem, ext.NewFileMenuExtensions, newToolStripMenuItem.DropDownItems.Count);
if (ext.NewFromFileMenuExtensions != null)
RegisterMenuExtIndex(newFromFileToolStripMenuItem, ext.NewFromFileMenuExtensions, newFromFileToolStripMenuItem.DropDownItems.Count);
if (ext.ToolsMenuExtensions != null)
RegisterMenuExtIndex(toolsToolStripMenuItem, ext.ToolsMenuExtensions);
if (ext.TitleBarExtensions != null)
RegisterMenuExtIndex(menuStrip1, ext.TitleBarExtensions, menuStrip1.Items.Count);
if (ext.ExperimentalMenuExtensions != null)
RegisterMenuExtIndex(experimentalToolStripMenuItem, ext.ExperimentalMenuExtensions, experimentalToolStripMenuItem.DropDownItems.Count);
if (ext.CompressionMenuExtensions != null)
RegisterMenuExtIndex(compressionToolStripMenuItem, ext.CompressionMenuExtensions, compressionToolStripMenuItem.DropDownItems.Count);
}
}
void RegisterMenuExtIndex(ToolStrip target, ToolStripButton[] list, int index = 0)
{
foreach (var i in list)
{
target.Items.Insert(index++, i);
}
}
void RegisterMenuExtIndex(ToolStripMenuItem target, STToolStripItem[] list, int index = 0)
{
foreach (STToolStripItem i in list)
{
if (i == null)
continue;
if (!MenuHasItem(target, i))
target.DropDownItems.Insert(index++, i);
else
MergeDuplicateMenus(i, GetDuplicateMenuItem(target, i));
}
}
bool MenuHasItem(ToolStripMenuItem target, STToolStripItem item)
{
foreach (ToolStripItem i in target.DropDownItems)
if (i.Text == item.Text)
return true;
return false;
}
STToolStripItem GetDuplicateMenuItem(ToolStripMenuItem target, STToolStripItem item)
{
foreach (STToolStripItem i in target.DropDownItems)
if (i.Text == item.Text)
return i;
return null;
}
void MergeDuplicateMenus(STToolStripItem src, STToolStripItem dest )
{
dest.DropDownItems.AddRange(src.DropDownItems);
}
void RegisterMenuExtIndex(ToolStrip target, STToolStripItem[] list, int index = 0)
{
foreach (var i in list)
target.Items.Insert(index++, i);
}
private void LoadMDITheme()
{
MDIController.MDIClientSupport.SetBevel(this, false);
MdiClient ctlMDI;
// Loop through all of the form's controls looking
// for the control of type MdiClient.
foreach (Control ctl in this.Controls)
{
try
{
// Attempt to cast the control to type MdiClient.
ctlMDI = (MdiClient)ctl;
// Set the BackColor of the MdiClient control.
ctlMDI.BackColor = FormThemes.BaseTheme.MDIParentBackColor;
}
catch (InvalidCastException exc)
{
// Catch and ignore the error if casting failed.
}
}
}
private void exitToolStripMenuItem_Click(object sender, EventArgs e)
{
Application.Exit();
}
#endregion
private IFileFormat GetActiveIFileFormat()
{
if (ActiveMdiChild is ObjectEditor)
{
return ((ObjectEditor)ActiveMdiChild).GetActiveFile();
}
else if (ActiveMdiChild is GenericEditorForm)
{
var control = ((GenericEditorForm)ActiveMdiChild).GetControl();
if (control != null && control is IFIleEditor)
{
if (((IFIleEditor)control).GetFileFormats().Count > 0)
return ((IFIleEditor)control).GetFileFormats()[0];
}
if (control != null && control is ImageEditorBase)
{
return (IFileFormat)((ImageEditorBase)control).ActiveTexture;
}
if (control != null && control is AudioPlayerPanel)
{
return ((AudioPlayerPanel)control).AudioFileFormats[0];
}
}
else if (ActiveMdiChild is IFIleEditor)
{
if (((IFIleEditor)ActiveMdiChild).GetFileFormats().Count > 0)
return ((IFIleEditor)ActiveMdiChild).GetFileFormats()[0];
}
else if (ActiveMdiChild is ImageEditorForm)
{
return ((ImageEditorForm)ActiveMdiChild).GetActiveFile();
}
else if (ActiveMdiChild is AudioPlayer)
{
if (((AudioPlayer)ActiveMdiChild).AudioFileFormats.Count > 0)
return ((AudioPlayer)ActiveMdiChild).AudioFileFormats[0];
}
return null;
}
private void SetFormatSettings(IFileFormat format)
{
ResetMenus();
if (format == null)
return;
if (format.CanSave)
{
saveAsToolStripMenuItem.Enabled = true;
saveToolStripMenuItem.Enabled = true;
saveToolStripButton.Enabled = true;
}
else
{
saveAsToolStripMenuItem.Enabled = false;
saveToolStripMenuItem.Enabled = false;
saveToolStripButton.Enabled = false;
}
var menuExtensions = FileManager.GetMenuExtensions(format);
editToolStripMenuItem.DropDownItems.Clear();
for (int i = 0; i < stToolStrip1.Items.Count; i++)
{
if (i > 1)
stToolStrip1.Items.RemoveAt(i);
}
if (menuExtensions != null)
{
if (menuExtensions.EditMenuExtensions != null)
{
RegisterMenuExtIndex(editToolStripMenuItem, menuExtensions.EditMenuExtensions, editToolStripMenuItem.DropDownItems.Count);
if (editToolStripMenuItem.DropDownItems.Count > 0)
editToolStripMenuItem.Enabled = true;
}
if (menuExtensions.IconButtonMenuExtensions != null)
{
RegisterMenuExtIndex(stToolStrip1, menuExtensions.IconButtonMenuExtensions, stToolStrip1.Items.Count);
}
}
}
private void ResetMenus()
{
editToolStripMenuItem.Enabled = false;
saveAsToolStripMenuItem.Enabled = false;
saveToolStripMenuItem.Enabled = false;
saveToolStripButton.Enabled = false;
}
#region Events
private void MainForm_KeyDown(object sender, KeyEventArgs e)
{
if (e.Control && e.KeyCode == Keys.O) // Ctrl + O Open
{
e.SuppressKeyPress = true;
OpenFileSelect();
}
else if (e.Control && e.Alt && e.KeyCode == Keys.S) // Ctrl + Alt + S Save As
{
e.SuppressKeyPress = true;
SaveActiveFile(true);
}
else if(e.Control && e.KeyCode == Keys.S) // Ctrl + S Save
{
e.SuppressKeyPress = true;
SaveActiveFile(false);
}
else if (e.Control && e.KeyCode == Keys.W) // Ctrl + W Exit
{
e.SuppressKeyPress = true;
var notify = MessageBox.Show("Are you sure you want to exit the application?", Application.ProductName, MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button1);
if (notify == DialogResult.OK)
Application.Exit();
}
}
private void saveAsToolStripMenuItem_Click(object sender, EventArgs e) {
SaveActiveFile();
}
private void saveToolStripMenuItem_Click(object sender, EventArgs e) {
SaveActiveFile(false);
}
private void saveToolStripButton_Click(object sender, EventArgs e) {
SaveActiveFile(false);
}
private void cascadeToolStripMenuItem_Click(object sender, EventArgs e)
{
LayoutMdi(MdiLayout.Cascade);
foreach (STForm frm in this.MdiChildren) frm.MDIWindowed();
}
private void tileHorizontalToolStripMenuItem_Click(object sender, EventArgs e)
{
this.SuspendLayout();
foreach (Form frm in this.MdiChildren) frm.FormBorderStyle = FormBorderStyle.FixedSingle;
LayoutMdi(MdiLayout.TileHorizontal);
foreach (Form frm in this.MdiChildren) frm.FormBorderStyle = FormBorderStyle.None;
this.ResumeLayout();
}
private void tileVerticleToolStripMenuItem_Click(object sender, EventArgs e)
{
LayoutMdi(MdiLayout.TileVertical);
}
private void arrangeIconsToolStripMenuItem_Click(object sender, EventArgs e)
{
LayoutMdi(MdiLayout.ArrangeIcons);
}
private void closeToolStripMenuItem_Click(object sender, EventArgs e)
{
if (ActiveMdiChild != null)
ActiveMdiChild.Close();
OnMdiWindowClosed();
//Force garbage collection.
GC.Collect();
// Wait for all finalizers to complete before continuing.
GC.WaitForPendingFinalizers();
}
private void closeAllToolStripMenuItem_Click(object sender, EventArgs e)
{
foreach (Form frm in this.MdiChildren) frm.Close();
OnMdiWindowClosed();
RenderTools.DisposeTextures();
//Force garbage collection.
GC.Collect();
// Wait for all finalizers to complete before continuing.
GC.WaitForPendingFinalizers();
}
private void OnMdiWindowClosed()
{
BtnMdiClose.Visible = false;
BtnMdiMinMax.Visible = false;
BtnMdiMinimize.Visible = false;
}
private void OnMdiWindowActived()
{
BtnMdiClose.Visible = true;
BtnMdiMinMax.Visible = true;
BtnMdiMinimize.Visible = true;
}
private void minimizeToolStripMenuItem_Click(object sender, EventArgs e)
{
if (ActiveMdiChild != null)
ActiveMdiChild.WindowState = FormWindowState.Minimized;
}
private void maximizeToolStripMenuItem_Click(object sender, EventArgs e)
{
if (ActiveMdiChild != null)
ActiveMdiChild.WindowState = FormWindowState.Maximized;
}
private void settingsToolStripMenuItem_Click(object sender, EventArgs e)
{
}
private void MainForm_DragEnter(object sender, DragEventArgs e)
{
if (!Runtime.EnableDragDrop) return;
if (e.Data.GetDataPresent(DataFormats.FileDrop))
e.Effect = DragDropEffects.All;
else
{
String[] strGetFormats = e.Data.GetFormats();
e.Effect = DragDropEffects.None;
}
}
private void MainForm_DragDrop(object sender, DragEventArgs e)
{
if (!Runtime.EnableDragDrop) return;
Cursor.Current = Cursors.WaitCursor;
string[] files = (string[])e.Data.GetData(DataFormats.FileDrop);
foreach (string filename in files)
{
OpenFile(filename);
}
Cursor.Current = Cursors.Default;
}
#endregion
#region TabMdiWindows
private void TabControlMouseDown(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Right && tabForms.SelectedTab != null)
{
tabControlContextMenuStrip.Show(Cursor.Position);
}
}
private void CloseTab(object sender, EventArgs e)
{
foreach (var child in this.MdiChildren)
{
if (child == tabForms.SelectedTab.Tag)
{
OnMdiWindowClosed();
child.Close();
return;
}
}
}
private void ResetAnimPanel()
{
if (LibraryGUI.GetAnimationPanel() != null)
{
LibraryGUI.GetAnimationPanel().CurrentAnimation = null;
}
}
bool IsChanged = false;
private void MainForm_MdiChildActivate(object sender, EventArgs e)
{
if (this.ActiveMdiChild == null)
{
tabForms.Visible = false;
ResetMenus();
}
// If no any child form, hide tabControl
else
{
if (IsChanged)
{
ResetAnimPanel();
IsChanged = false;
}
// If child form is new and no has tabPage,
// create new tabPage
if (this.ActiveMdiChild.Tag == null)
{
if (Runtime.MaximizeMdiWindow && ActiveMdiChild.WindowState != FormWindowState.Maximized)
{
((STForm)this.ActiveMdiChild).Maximize();
}
int tpIndex = 0;
foreach (TabPage tpCheck in tabForms.TabPages)
{
if (tpCheck.Text == this.ActiveMdiChild.Text)
{
tabForms.SelectedIndex = tpIndex;
return;
}
tpIndex++;
}
// Add a tabPage to tabControl with child
// form caption
TabPage tp = new TabPage(this.ActiveMdiChild.Text);
tp.BackColor = FormThemes.BaseTheme.TabPageInactive;
tp.ForeColor = FormThemes.BaseTheme.FormContextMenuForeColor;
tp.Tag = this.ActiveMdiChild;
tp.Parent = tabForms;
tabForms.SelectedTab = tp;
tabForms.SelectedTab.BackColor = FormThemes.BaseTheme.TabPageActive;
this.ActiveMdiChild.Tag = tp;
this.ActiveMdiChild.FormClosed +=
new FormClosedEventHandler(ActiveMdiChild_FormClosed);
this.ActiveMdiChild.SizeChanged +=
new EventHandler(ActiveMdiChild_StateChanged);
}
else
{
//Select a tab if it has a tag
int tpIndex = 0;
foreach (TabPage tpCheck in tabForms.TabPages)
{
if (tpCheck.Tag == this.ActiveMdiChild)
{
tabForms.SelectedIndex = tpIndex;
if (ActiveMdiChild is STForm) {
if (ActiveMdiChild.WindowState == FormWindowState.Maximized) {
((STForm)ActiveMdiChild).MDIMaximized();
}
}
return;
}
tpIndex++;
}
}
if (!tabForms.Visible) tabForms.Visible = true;
}
}
private void ActiveMdiChild_StateChanged(object sender, EventArgs e)
{
if (ActiveMdiChild == null)
return;
if (ActiveMdiChild.WindowState == FormWindowState.Maximized)
OnMdiWindowActived();
else
OnMdiWindowClosed();
}
private const int WM_SETREDRAW = 11;
[DllImport("user32.dll")]
public static extern int SendMessage(IntPtr hWnd, Int32 wMsg, bool wParam, Int32 lParam);
private void ActiveMdiChild_FormClosed(object sender,
FormClosedEventArgs e)
{
((sender as Form).Tag as TabPage).Dispose();
}
private void tabForms_SelectedIndexChanged(object sender, EventArgs e)
{
foreach (TabPage tpCheck in tabForms.TabPages)
tpCheck.BackColor = FormThemes.BaseTheme.TabPageInactive;
SetFormatSettings(GetActiveIFileFormat());
IsChanged = true;
if (tabForms.SelectedTab != null)
{
tabForms.SelectedTab.BackColor = FormThemes.BaseTheme.TabPageActive;
}
if ((tabForms.SelectedTab != null) &&
(tabForms.SelectedTab.Tag != null))
{
SendMessage(this.Handle, WM_SETREDRAW, false, 0);
(tabForms.SelectedTab.Tag as Form).Select();
SendMessage(this.Handle, WM_SETREDRAW, true, 0);
this.Refresh();
}
}
#endregion
private void mainSettingsToolStripMenuItem_Click(object sender, EventArgs e)
{
Settings settings = new Settings();
settings.Show(this);
}
private void fileAssociationsToolStripMenuItem_Click(object sender, EventArgs e)
{
FileAssociationForm form = new FileAssociationForm();
form.ShowDialog();
}
private void menuStrip1_ItemClicked(object sender, ToolStripItemClickedEventArgs e)
{
}
private void creditsToolStripMenuItem_Click(object sender, EventArgs e)
{
}
private void BtnMinMax_Click(object sender, EventArgs e)
{
}
private void BtnMinMax_MouseEnter(object sender, EventArgs e)
{
}
private void BtnMinMax_MouseLeave(object sender, EventArgs e)
{
}
private void BtnClose_Click(object sender, EventArgs e)
{
}
private void BtnClose_MouseEnter(object sender, EventArgs e)
{
}
private void BtnClose_MouseLeave(object sender, EventArgs e)
{
}
private void BtnMdiClose_MouseEnter(object sender, System.EventArgs e)
{
BtnMdiClose.Image = Toolbox.Library.Properties.Resources.Close_Hover;
}
private void BtnMdiClose_MouseLeave(object sender, System.EventArgs e)
{
BtnMdiClose.Image = Toolbox.Library.Properties.Resources.Close;
}
private void BtnMdiMinMax_MouseEnter(object sender, EventArgs e)
{
BtnMdiMinMax.Image = Toolbox.Library.Properties.Resources.maximize_sele;
}
private void BtnMdiMinMax_MouseLeave(object sender, EventArgs e)
{
BtnMdiMinMax.Image = Toolbox.Library.Properties.Resources.maximize;
}
private void BtnMdiMinimize_MouseEnter(object sender, EventArgs e)
{
BtnMdiMinimize.Image = Toolbox.Library.Properties.Resources.minimize_sele;
}
private void BtnMdiMinimize_MouseLeave(object sender, EventArgs e)
{
BtnMdiMinimize.Image = Toolbox.Library.Properties.Resources.minimize;
}
private void BtnMdiClose_Click(object sender, EventArgs e)
{
foreach (var child in this.MdiChildren)
{
if (child == tabForms.SelectedTab.Tag)
{
OnMdiWindowClosed();
child.Close();
GC.Collect();
return;
}
}
}
private void BtnMdiMinMax_Click(object sender, EventArgs e)
{
LayoutMdi(MdiLayout.Cascade);
foreach (STForm frm in this.MdiChildren) frm.MDIWindowed();
}
private void BtnMdiMinimize_Click(object sender, EventArgs e)
{
if (ActiveMdiChild != null)
ActiveMdiChild.WindowState = FormWindowState.Minimized;
}
private void updateToolstrip_Click(object sender, EventArgs e) {
UpdateNotifcationClick();
}
private void tabForms_MouseClick(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Right)
{
this.tabControlContextMenuStrip.Show(this.tabForms, e.Location);
}
}
STConsoleForm form;
private void consoleToolStripMenuItem_Click(object sender, EventArgs e)
{
if (form == null || form.IsDisposed)
{
form = new STConsoleForm();
form.Show(this);
}
form.Focus();
}
private void aboutToolStripMenuItem1_Click(object sender, EventArgs e)
{
CreditsWindow window = new CreditsWindow();
window.Show();
}
private void githubToolStripMenuItem_Click(object sender, EventArgs e)
{
System.Diagnostics.Process.Start("https://github.com/KillzXGaming/Switch-Toolbox");
}
private void reportBugToolStripMenuItem_Click(object sender, EventArgs e) {
System.Diagnostics.Process.Start("https://github.com/KillzXGaming/Switch-Toolbox/issues");
}
private void requestFeatureToolStripMenuItem1_Click(object sender, EventArgs e) {
System.Diagnostics.Process.Start("https://github.com/KillzXGaming/Switch-Toolbox/issues");
}
private void tutorialToolStripMenuItem_Click(object sender, EventArgs e) {
System.Diagnostics.Process.Start("https://github.com/KillzXGaming/Switch-Toolbox/wiki");
}
private void checkShaderErrorsToolStripMenuItem_Click(object sender, EventArgs e)
{
ShaderTools.SaveErrorLogs();
}
private void MainForm_FormClosing(object sender, FormClosingEventArgs e) {
}
private void batchToolStripMenuItem_Click(object sender, EventArgs e)
{
FolderSelectDialog folderDlg = new FolderSelectDialog();
if (folderDlg.ShowDialog() == DialogResult.OK)
{
STFileSaver.BatchFileTable(folderDlg.SelectedPath);
}
}
private void hashCalculatorToolStripMenuItem_Click(object sender, EventArgs e)
{
HashCalculatorForm form = new HashCalculatorForm();
form.Show(this);
}
private void batchExportTexturesAllSupportedFormatsToolStripMenuItem_Click(object sender, EventArgs e)
{
OpenFileDialog ofd = new OpenFileDialog();
ofd.Multiselect = true;
if (ofd.ShowDialog() == DialogResult.OK)
{
FolderSelectDialog folderDlg = new FolderSelectDialog();
if (folderDlg.ShowDialog() == DialogResult.OK) {
BatchExportTextures(ofd.FileNames, folderDlg.SelectedPath);
}
}
}
private void BatchExportTextures(string[] files, string outputFolder)
{
List<string> Formats = new List<string>();
Formats.Add("Portable Graphics Network (.png)");
Formats.Add("Microsoft DDS (.dds)");
Formats.Add("Joint Photographic Experts Group (.jpg)");
Formats.Add("Bitmap Image (.bmp)");
Formats.Add("Tagged Image File Format (.tiff)");
Formats.Add("ASTC (.astc)");
List<string> failedFiles = new List<string>();
BatchFormatExport form = new BatchFormatExport(Formats);
if (form.ShowDialog() == DialogResult.OK)
{
string extension = form.GetSelectedExtension();
foreach (var file in files)
{
try
{
var fileFormat = STFileLoader.OpenFileFormat(file);
SearchFileFormat(form.BatchSettings, fileFormat, extension, outputFolder);
}
catch
{
failedFiles.Add(file);
}
}
}
if (failedFiles.Count > 0)
{
string detailList = "";
foreach (var file in failedFiles)
detailList += $"{file}\n";
STErrorDialog.Show("Some files failed to export! See detail list of failed files.", "Switch Toolbox", detailList);
}
else
MessageBox.Show("Files batched successfully!");
}
private void SearchFileFormat(BatchFormatExport.Settings settings, IFileFormat fileFormat, string extension, string outputFolder)
{
if (fileFormat == null) return;
if (fileFormat is STGenericTexture)
ExportTexture(((STGenericTexture)fileFormat), $"{outputFolder}/{fileFormat.FileName}.{extension}");
else if (fileFormat is IArchiveFile)
SearchArchive(settings, (IArchiveFile)fileFormat, extension, outputFolder);
else if (fileFormat is ITextureContainer)
{
if (settings.SeperateTextureContainers)
{
outputFolder = Path.Combine(outputFolder, fileFormat.FileName);
if (!Directory.Exists(outputFolder))
Directory.CreateDirectory(outputFolder);
}
foreach (STGenericTexture tex in ((ITextureContainer)fileFormat).TextureList) {
ExportTexture(tex, $"{outputFolder}/{tex.Text}.{extension}");
}
}
fileFormat.Unload();
}
private void ExportTexture(STGenericTexture tex, string filePath) {
tex.Export(filePath);
}
private void SearchArchive(BatchFormatExport.Settings settings, IArchiveFile archiveFile, string extension, string outputFolder)
{
string ArchiveFilePath = Path.Combine(outputFolder, Path.GetFileNameWithoutExtension(((IFileFormat)archiveFile).FileName));
if (!Directory.Exists(ArchiveFilePath))
Directory.CreateDirectory(ArchiveFilePath);
else
ArchiveFilePath = outputFolder;
foreach (var file in archiveFile.Files)
SearchFileFormat(settings, file.OpenFile(), extension, ArchiveFilePath);
}
}
}