mirror of
https://git.do.srb2.org/STJr/UltimateZoneBuilder.git
synced 2024-12-11 21:01:22 +00:00
2246 lines
68 KiB
C#
Executable file
2246 lines
68 KiB
C#
Executable file
|
|
#region ================== Copyright (c) 2007 Pascal vd Heiden
|
|
|
|
/*
|
|
* Copyright (c) 2007 Pascal vd Heiden, www.codeimp.com
|
|
* This program is released under GNU General Public License
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
*/
|
|
|
|
#endregion
|
|
|
|
#region ================== Namespaces
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Drawing;
|
|
using System.IO;
|
|
using System.Windows.Forms;
|
|
using CodeImp.DoomBuilder.Compilers;
|
|
using CodeImp.DoomBuilder.Config;
|
|
using CodeImp.DoomBuilder.Controls.Scripting;
|
|
using CodeImp.DoomBuilder.Data;
|
|
using CodeImp.DoomBuilder.Data.Scripting;
|
|
using CodeImp.DoomBuilder.Windows;
|
|
using ScintillaNET;
|
|
|
|
#endregion
|
|
|
|
namespace CodeImp.DoomBuilder.Controls
|
|
{
|
|
internal partial class ScriptEditorPanel : UserControl
|
|
{
|
|
#region ================== Constants
|
|
|
|
private static readonly Color QUICKSEARCH_FAIL_COLOR = Color.MistyRose; //mxd
|
|
|
|
#endregion
|
|
|
|
#region ================== Variables
|
|
|
|
private List<ScriptConfiguration> scriptconfigs;
|
|
private List<CompilerError> compilererrors;
|
|
|
|
// Find/Replace
|
|
private ScriptFindReplaceForm findreplaceform;
|
|
private FindReplaceOptions findoptions;
|
|
|
|
// Quick search bar settings (mxd)
|
|
private static bool matchwholeword;
|
|
private static bool matchcase;
|
|
|
|
//mxd. Status update
|
|
private ScriptStatusInfo status;
|
|
private int statusflashcount;
|
|
private bool statusflashicon;
|
|
|
|
//mxd
|
|
private ScriptEditorForm parentform;
|
|
private ScriptIconsManager iconsmgr;
|
|
|
|
//mxd. Text editor settings
|
|
private bool showwhitespace;
|
|
private bool wraplonglines;
|
|
private bool blockupdate;
|
|
|
|
#endregion
|
|
|
|
#region ================== Properties
|
|
|
|
public ScriptDocumentTab ActiveTab { get { return (tabs.SelectedTab as ScriptDocumentTab); } }
|
|
internal ScriptIconsManager Icons { get { return iconsmgr; } }
|
|
internal ScriptResourcesControl ScriptResourcesControl { get { return scriptresources; } }
|
|
public bool ShowWhitespace { get { return showwhitespace; } }
|
|
public bool WrapLongLines { get { return wraplonglines; } }
|
|
|
|
#endregion
|
|
|
|
#region ================== Constructor
|
|
|
|
// Constructor
|
|
public ScriptEditorPanel()
|
|
{
|
|
InitializeComponent();
|
|
iconsmgr = new ScriptIconsManager(scripticons); //mxd
|
|
tabs.ImageList = scripticons; //mxd
|
|
}
|
|
|
|
// This initializes the control
|
|
public void Initialize(ScriptEditorForm form)
|
|
{
|
|
parentform = form; //mxd
|
|
|
|
// Make list of script configs
|
|
scriptconfigs = new List<ScriptConfiguration>(General.ScriptConfigs.Values);
|
|
scriptconfigs.Add(new ScriptConfiguration());
|
|
scriptconfigs.Sort();
|
|
|
|
// Fill the list of new document types
|
|
foreach(ScriptConfiguration cfg in scriptconfigs)
|
|
{
|
|
Image icon = scripticons.Images[iconsmgr.GetScriptIcon(cfg.ScriptType)]; //mxd
|
|
|
|
// Button for new script menu
|
|
ToolStripMenuItem item = new ToolStripMenuItem(cfg.Description);
|
|
item.Image = icon; //mxd
|
|
item.Tag = cfg;
|
|
item.Click += buttonnew_Click;
|
|
buttonnew.DropDownItems.Add(item);
|
|
|
|
// Button for script type menu
|
|
item = new ToolStripMenuItem(cfg.Description);
|
|
item.Image = icon; //mxd
|
|
item.Tag = cfg;
|
|
item.Click += buttonscriptconfig_Click;
|
|
buttonscriptconfig.DropDownItems.Add(item);
|
|
|
|
//mxd. Button for the "New" menu item
|
|
item = new ToolStripMenuItem(cfg.Description);
|
|
item.Image = icon; //mxd
|
|
item.Tag = cfg;
|
|
item.Click += buttonnew_Click;
|
|
menunew.DropDownItems.Add(item);
|
|
}
|
|
|
|
// Setup supported extensions
|
|
string filterall = "";
|
|
string filterseperate = "";
|
|
foreach(ScriptConfiguration cfg in scriptconfigs)
|
|
{
|
|
if(cfg.Extensions.Length > 0)
|
|
{
|
|
string exts = "*." + string.Join(";*.", cfg.Extensions);
|
|
if(filterseperate.Length > 0) filterseperate += "|";
|
|
filterseperate += cfg.Description + "|" + exts;
|
|
if(filterall.Length > 0) filterall += ";";
|
|
filterall += exts;
|
|
}
|
|
}
|
|
openfile.Filter = "Script files|" + filterall + "|" + filterseperate + "|All files|*.*";
|
|
|
|
//mxd. Initialize script resources control
|
|
scriptresources.Setup(this, General.Map.Data.ScriptResources);
|
|
|
|
//mxd. Initialize "find usages" control
|
|
findusages.Setup(this);
|
|
|
|
// Load the script lumps
|
|
ScriptDocumentTab activetab = null; //mxd
|
|
foreach(MapLumpInfo maplumpinfo in General.Map.Config.MapLumps.Values)
|
|
{
|
|
// Is this a script lump?
|
|
if(maplumpinfo.ScriptBuild) //mxd
|
|
{
|
|
ScriptConfiguration config = General.GetScriptConfiguration(ScriptType.ACS);
|
|
if(config == null)
|
|
{
|
|
General.ErrorLogger.Add(ErrorType.Warning, "Unable to find script configuration for \"" + ScriptType.ACS + "\" script type. Using plain text configuration.");
|
|
config = new ScriptConfiguration();
|
|
}
|
|
|
|
// Load this!
|
|
ScriptLumpDocumentTab t = new ScriptLumpDocumentTab(this, maplumpinfo.Name, config);
|
|
|
|
//mxd. Apply stored settings?
|
|
if(General.Map.Options.ScriptDocumentSettings.ContainsKey(maplumpinfo.Name))
|
|
{
|
|
t.SetViewSettings(General.Map.Options.ScriptDocumentSettings[maplumpinfo.Name]);
|
|
if(General.Map.Options.ScriptDocumentSettings[maplumpinfo.Name].IsActiveTab)
|
|
activetab = t;
|
|
}
|
|
else
|
|
{
|
|
t.SetDefaultViewSettings();
|
|
}
|
|
|
|
t.OnTextChanged += tabpage_OnLumpTextChanged; //mxd
|
|
t.Editor.Scintilla.UpdateUI += scintilla_OnUpdateUI; //mxd
|
|
tabs.TabPages.Add(t);
|
|
}
|
|
else if(maplumpinfo.Script != null)
|
|
{
|
|
// Load this!
|
|
ScriptLumpDocumentTab t = new ScriptLumpDocumentTab(this, maplumpinfo.Name, maplumpinfo.Script);
|
|
|
|
//mxd. Apply stored settings?
|
|
if(General.Map.Options.ScriptDocumentSettings.ContainsKey(maplumpinfo.Name))
|
|
{
|
|
t.SetViewSettings(General.Map.Options.ScriptDocumentSettings[maplumpinfo.Name]);
|
|
if(General.Map.Options.ScriptDocumentSettings[maplumpinfo.Name].IsActiveTab)
|
|
activetab = t;
|
|
}
|
|
else
|
|
{
|
|
t.SetDefaultViewSettings();
|
|
}
|
|
|
|
t.OnTextChanged += tabpage_OnLumpTextChanged; //mxd
|
|
t.Editor.Scintilla.UpdateUI += scintilla_OnUpdateUI; //mxd
|
|
tabs.TabPages.Add(t);
|
|
}
|
|
}
|
|
|
|
// Load files, which were previously opened for this map
|
|
foreach(ScriptDocumentSettings settings in General.Map.Options.ScriptDocumentSettings.Values)
|
|
{
|
|
switch(settings.TabType)
|
|
{
|
|
//TODO: load all tab types here...
|
|
case ScriptDocumentTabType.LUMP: continue;
|
|
|
|
case ScriptDocumentTabType.FILE:
|
|
// Does this file exist?
|
|
if(File.Exists(settings.Filename))
|
|
{
|
|
// Load this!
|
|
ScriptFileDocumentTab t = OpenFile(settings.Filename, settings.ScriptType);
|
|
t.SetViewSettings(settings); //mxd
|
|
if(settings.IsActiveTab) activetab = t;
|
|
}
|
|
break;
|
|
|
|
case ScriptDocumentTabType.RESOURCE:
|
|
// Find target resource...
|
|
if(!General.Map.Data.ScriptResources.ContainsKey(settings.ScriptType)) continue;
|
|
foreach(ScriptResource res in General.Map.Data.ScriptResources[settings.ScriptType])
|
|
{
|
|
if(res.Resource.Location.location == settings.ResourceLocation)
|
|
{
|
|
// Load this!
|
|
ScriptResourceDocumentTab t = OpenResource(res);
|
|
t.SetViewSettings(settings);
|
|
if(settings.IsActiveTab) activetab = t;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
throw new NotImplementedException("Unknown ScriptDocumentTabType!");
|
|
}
|
|
}
|
|
|
|
//mxd. Reselect previously selected tab
|
|
if(activetab != null)
|
|
{
|
|
tabs.SelectedTab = activetab;
|
|
}
|
|
//mxd. Select the "Scripts" tab, because that's what user will want 99% of time
|
|
else if(tabs.TabPages.Count > 0)
|
|
{
|
|
int scriptsindex = -1;
|
|
for(int i = 0; i < tabs.TabPages.Count; i++)
|
|
{
|
|
if(tabs.TabPages[i].Text == "SCRIPTS")
|
|
{
|
|
scriptsindex = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
tabs.SelectedIndex = (scriptsindex == -1 ? 0 : scriptsindex);
|
|
activetab = tabs.TabPages[tabs.SelectedIndex] as ScriptDocumentTab;
|
|
}
|
|
|
|
//mxd. Apply quick search settings
|
|
searchmatchcase.Checked = matchcase;
|
|
searchwholeword.Checked = matchwholeword;
|
|
searchbox_TextChanged(this, EventArgs.Empty);
|
|
|
|
//mxd. If the map or script navigator has any compile errors, show them
|
|
if(activetab != null)
|
|
{
|
|
List<CompilerError> errors = (General.Map.Errors.Count > 0 ? General.Map.Errors : activetab.UpdateNavigator());
|
|
if(errors.Count > 0) ShowErrors(errors, false);
|
|
else ClearErrors();
|
|
}
|
|
else
|
|
{
|
|
ClearErrors();
|
|
}
|
|
|
|
// Done
|
|
UpdateInterface(true);
|
|
}
|
|
|
|
// This applies user preferences
|
|
public void ApplySettings()
|
|
{
|
|
// Set Errors panel settings
|
|
errorlist.Columns[0].Width = General.Settings.ReadSetting("scriptspanel.errorscolumn0width", errorlist.Columns[0].Width);
|
|
errorlist.Columns[1].Width = General.Settings.ReadSetting("scriptspanel.errorscolumn1width", errorlist.Columns[1].Width);
|
|
errorlist.Columns[2].Width = General.Settings.ReadSetting("scriptspanel.errorscolumn2width", errorlist.Columns[2].Width);
|
|
|
|
//mxd. Set script navigator splitter position and state
|
|
if(General.Settings.ReadSetting("scriptspanel.splittercollapsed", false))
|
|
mainsplitter.IsCollapsed = true;
|
|
|
|
int splitterdistance = General.Settings.ReadSetting("scriptspanel.splitterdistance", int.MinValue);
|
|
if(splitterdistance == int.MinValue)
|
|
{
|
|
splitterdistance = 200;
|
|
if(MainForm.DPIScaler.Width != 1.0f)
|
|
splitterdistance = (int)Math.Round(splitterdistance * MainForm.DPIScaler.Width);
|
|
}
|
|
mainsplitter.SplitPosition = splitterdistance;
|
|
|
|
//mxd. Set script splitter position and state
|
|
if(General.Settings.ReadSetting("scriptspanel.scriptsplittercollapsed", false))
|
|
scriptsplitter.IsCollapsed = true;
|
|
|
|
splitterdistance = General.Settings.ReadSetting("scriptspanel.scriptsplitterdistance", int.MinValue);
|
|
if(splitterdistance == int.MinValue)
|
|
{
|
|
splitterdistance = 250;
|
|
if(MainForm.DPIScaler.Width != 1.0f)
|
|
splitterdistance = (int)Math.Round(splitterdistance * MainForm.DPIScaler.Width);
|
|
}
|
|
scriptsplitter.SplitPosition = splitterdistance;
|
|
|
|
//mxd. Selected info tab
|
|
infotabs.SelectedIndex = General.Settings.ReadSetting("scriptspanel.infotabindex", 0);
|
|
|
|
//mxd. Set text editor settings
|
|
showwhitespace = General.Settings.ReadSetting("scriptspanel.showwhitespace", false);
|
|
buttonwhitespace.Checked = showwhitespace;
|
|
menuwhitespace.Checked = showwhitespace;
|
|
wraplonglines = General.Settings.ReadSetting("scriptspanel.wraplonglines", false);
|
|
buttonwordwrap.Checked = wraplonglines;
|
|
menuwordwrap.Checked = wraplonglines;
|
|
menustayontop.Checked = General.Settings.ScriptOnTop;
|
|
ApplyTabSettings();
|
|
}
|
|
|
|
// This saves user preferences
|
|
public void SaveSettings()
|
|
{
|
|
General.Settings.WriteSetting("scriptspanel.errorscolumn0width", errorlist.Columns[0].Width);
|
|
General.Settings.WriteSetting("scriptspanel.errorscolumn1width", errorlist.Columns[1].Width);
|
|
General.Settings.WriteSetting("scriptspanel.errorscolumn2width", errorlist.Columns[2].Width); //mxd
|
|
General.Settings.WriteSetting("scriptspanel.splittercollapsed", mainsplitter.IsCollapsed); //mxd
|
|
General.Settings.WriteSetting("scriptspanel.splitterdistance", mainsplitter.SplitPosition); //mxd
|
|
General.Settings.WriteSetting("scriptspanel.scriptsplittercollapsed", scriptsplitter.IsCollapsed); //mxd
|
|
General.Settings.WriteSetting("scriptspanel.scriptsplitterdistance", scriptsplitter.SplitPosition); //mxd
|
|
General.Settings.WriteSetting("scriptspanel.infotabindex", infotabs.SelectedIndex); //mxd
|
|
General.Settings.WriteSetting("scriptspanel.showwhitespace", showwhitespace); //mxd
|
|
General.Settings.WriteSetting("scriptspanel.wraplonglines", wraplonglines); //mxd
|
|
}
|
|
|
|
//mxd
|
|
private void ApplyTabSettings()
|
|
{
|
|
foreach(var tp in tabs.TabPages)
|
|
{
|
|
ScriptDocumentTab scripttab = (tp as ScriptDocumentTab);
|
|
if(scripttab != null)
|
|
{
|
|
scripttab.WrapLongLines = buttonwordwrap.Checked;
|
|
scripttab.ShowWhitespace = buttonwhitespace.Checked;
|
|
}
|
|
}
|
|
}
|
|
|
|
//mxd
|
|
internal void OnReloadResources()
|
|
{
|
|
// Re-initialize script resources control
|
|
scriptresources.Setup(this, General.Map.Data.ScriptResources);
|
|
|
|
// Resource tabs may need re-linking...
|
|
foreach(var tp in tabs.TabPages)
|
|
{
|
|
var tab = (tp as ScriptResourceDocumentTab);
|
|
if(tab != null) tab.OnReloadResources();
|
|
}
|
|
}
|
|
|
|
//mxd. Handle heavy resource loss
|
|
internal void OnScriptResourceLost(ScriptResourceDocumentTab sourcetab)
|
|
{
|
|
// Resource was lost. Remove tab
|
|
if(!sourcetab.IsChanged)
|
|
{
|
|
tabs.TabPages.Remove(sourcetab);
|
|
}
|
|
// Resource was lost, but the tab contains unsaved changes. Replace it with ScriptFileDocumentTab
|
|
else
|
|
{
|
|
int tabindex = tabs.TabPages.IndexOf(sourcetab);
|
|
var newtab = new ScriptFileDocumentTab(sourcetab);
|
|
|
|
tabs.SuspendLayout();
|
|
tabs.TabPages.Remove(sourcetab);
|
|
tabs.TabPages.Insert(tabindex, newtab);
|
|
tabs.ResumeLayout();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Methods
|
|
|
|
// [ZZ] Find and Replace
|
|
// This needs to be done in the script editor class, because we don't want to loop over the same value
|
|
// And for this, we need to know the context properly, not just "while FindNext && Replace".
|
|
// Which means there should be a function that does both find and replace manually.
|
|
public int FindReplace(FindReplaceOptions options)
|
|
{
|
|
// [ZZ] why do we require current tab for "find everywhere" and "replace everywhere"?
|
|
// todo: understand and refactor
|
|
//
|
|
// [ZZ] note: if we want CURRENT_*, error out if no active tab.
|
|
FindReplaceOptions singlesearchoptions = new FindReplaceOptions(options) { SearchMode = FindReplaceSearchMode.CURRENT_FILE };
|
|
List<ScriptDocumentTab> rtabs = new List<ScriptDocumentTab>();
|
|
switch (options.SearchMode)
|
|
{
|
|
// we really need a bitfield here. Whatever.
|
|
case FindReplaceSearchMode.CURRENT_FILE:
|
|
if (ActiveTab == null)
|
|
return 0;
|
|
rtabs.Add(ActiveTab);
|
|
break;
|
|
|
|
case FindReplaceSearchMode.OPENED_TABS_CURRENT_SCRIPT_TYPE:
|
|
if (ActiveTab == null)
|
|
return 0;
|
|
// .NET is heavily retarded
|
|
goto case FindReplaceSearchMode.OPENED_TABS_ALL_SCRIPT_TYPES;
|
|
case FindReplaceSearchMode.OPENED_TABS_ALL_SCRIPT_TYPES:
|
|
foreach (ScriptDocumentTab tab in tabs.TabPages)
|
|
{
|
|
if (options.SearchMode == FindReplaceSearchMode.OPENED_TABS_ALL_SCRIPT_TYPES ||
|
|
tab.Config.ScriptType == ActiveTab.Config.ScriptType) rtabs.Add(tab);
|
|
}
|
|
break;
|
|
|
|
case FindReplaceSearchMode.CURRENT_PROJECT_CURRENT_SCRIPT_TYPE:
|
|
if (ActiveTab == null)
|
|
return 0;
|
|
// .NET is heavily retarded
|
|
goto case FindReplaceSearchMode.CURRENT_PROJECT_ALL_SCRIPT_TYPES;
|
|
case FindReplaceSearchMode.CURRENT_PROJECT_ALL_SCRIPT_TYPES:
|
|
// Just search among all resources
|
|
var usedscripttypes = new List<ScriptType>(General.Map.Data.ScriptResources.Keys);
|
|
for (int i = 0; i < usedscripttypes.Count; i++)
|
|
{
|
|
if (options.SearchMode != FindReplaceSearchMode.CURRENT_PROJECT_ALL_SCRIPT_TYPES &&
|
|
usedscripttypes[i] != ActiveTab.Config.ScriptType) continue; // [ZZ] skip irrelevant script types
|
|
foreach (ScriptResource sr in General.Map.Data.ScriptResources[usedscripttypes[i]])
|
|
{
|
|
if (!sr.IsReadOnly && sr.ContainsText(singlesearchoptions))
|
|
{
|
|
// open this tab
|
|
var newtab = OpenResource(sr);
|
|
rtabs.Add(newtab);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
int replacements = 0;
|
|
foreach (ScriptDocumentTab tab in rtabs)
|
|
{
|
|
// do find/replace in the current tab.
|
|
// make sure that we don't find the same thing twice in case replacement has part of it's value.
|
|
int firstPosition = -1;
|
|
int lengthDifference = options.ReplaceWith.Length - options.FindText.Length;
|
|
int lastSelectionStart = -1;
|
|
int lastSelectionEnd = -1;
|
|
while (true)
|
|
{
|
|
if (!tab.FindNext(singlesearchoptions))
|
|
break;
|
|
if (firstPosition < 0)
|
|
firstPosition = tab.SelectionStart;
|
|
else if (tab.SelectionStart == firstPosition) // found the first
|
|
{
|
|
tab.SelectionStart = lastSelectionStart;
|
|
tab.SelectionEnd = lastSelectionEnd;
|
|
break;
|
|
}
|
|
if (tab.SelectionStart < firstPosition) // offset the first position with string length difference if we are replacing before it.
|
|
firstPosition += lengthDifference;
|
|
// do replacement
|
|
tab.ReplaceSelection(options.ReplaceWith);
|
|
//
|
|
lastSelectionStart = tab.SelectionStart;
|
|
lastSelectionEnd = tab.SelectionEnd;
|
|
replacements++;
|
|
}
|
|
}
|
|
|
|
return replacements;
|
|
}
|
|
|
|
// Find Next
|
|
public bool FindNext(FindReplaceOptions options)
|
|
{
|
|
// Save the options
|
|
findoptions = options;
|
|
return FindNext();
|
|
}
|
|
|
|
// Find Next with saved options
|
|
public bool FindNext()
|
|
{
|
|
if(!string.IsNullOrEmpty(findoptions.FindText) && (ActiveTab != null))
|
|
{
|
|
if(!ActiveTab.FindNext(findoptions))
|
|
{
|
|
DisplayStatus(ScriptStatusType.Warning, "Can't find any occurrence of \"" + findoptions.FindText + "\".");
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
General.MessageBeep(MessageBeepType.Default);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Find Previous
|
|
public bool FindPrevious(FindReplaceOptions options)
|
|
{
|
|
// Save the options
|
|
findoptions = options;
|
|
return FindPrevious();
|
|
}
|
|
|
|
// Find Previous with saved options (mxd)
|
|
public bool FindPrevious()
|
|
{
|
|
if(!string.IsNullOrEmpty(findoptions.FindText) && (ActiveTab != null))
|
|
{
|
|
if(!ActiveTab.FindPrevious(findoptions))
|
|
{
|
|
DisplayStatus(ScriptStatusType.Warning, "Can't find any occurrence of \"" + findoptions.FindText + "\".");
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
General.MessageBeep(MessageBeepType.Default);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//mxd
|
|
public bool FindNextWrapAround(FindReplaceOptions options)
|
|
{
|
|
var curtab = ActiveTab;
|
|
if(curtab == null) return false; // Boilerplate
|
|
switch(options.SearchMode)
|
|
{
|
|
case FindReplaceSearchMode.CURRENT_FILE: return false; // Let the tab handle wrap-around
|
|
|
|
case FindReplaceSearchMode.OPENED_TABS_CURRENT_SCRIPT_TYPE:
|
|
case FindReplaceSearchMode.OPENED_TABS_ALL_SCRIPT_TYPES:
|
|
ScriptType targettabtype = curtab.Config.ScriptType;
|
|
bool checktabtype = (options.SearchMode == FindReplaceSearchMode.OPENED_TABS_CURRENT_SCRIPT_TYPE);
|
|
|
|
// Search in processed tab only
|
|
var searchoptions = new FindReplaceOptions(options) { SearchMode = FindReplaceSearchMode.CURRENT_FILE };
|
|
|
|
// Find next suitable tab...
|
|
int start = tabs.TabPages.IndexOf(curtab);
|
|
|
|
// Search after current tab
|
|
for(int i = start + 1; i < tabs.TabPages.Count; i++)
|
|
{
|
|
var t = tabs.TabPages[i] as ScriptDocumentTab;
|
|
if(t != null && (!checktabtype || t.Config.ScriptType == targettabtype) && t.FindNext(searchoptions))
|
|
{
|
|
// Next match found!
|
|
tabs.SelectTab(t);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Search before current tab
|
|
if(start > 0)
|
|
{
|
|
for(int i = 0; i < start; i++)
|
|
{
|
|
var t = tabs.TabPages[i] as ScriptDocumentTab;
|
|
if(t != null && (!checktabtype || t.Config.ScriptType == targettabtype) && t.FindNext(searchoptions))
|
|
{
|
|
// Next match found!
|
|
tabs.SelectTab(t);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// No dice
|
|
return false;
|
|
|
|
case FindReplaceSearchMode.CURRENT_PROJECT_CURRENT_SCRIPT_TYPE:
|
|
case FindReplaceSearchMode.CURRENT_PROJECT_ALL_SCRIPT_TYPES:
|
|
ScriptType targetrestype = curtab.Config.ScriptType;
|
|
bool searchallresources = (options.SearchMode == FindReplaceSearchMode.CURRENT_PROJECT_ALL_SCRIPT_TYPES);
|
|
|
|
// Search in processed tab only
|
|
var ressearchoptions = new FindReplaceOptions(options) { SearchMode = FindReplaceSearchMode.CURRENT_FILE };
|
|
bool replacemode = (options.ReplaceWith != null);
|
|
|
|
// Find current resource, then search
|
|
if(General.Map.Data.ScriptResources.ContainsKey(targetrestype))
|
|
{
|
|
var reslist = new List<ScriptResource>(General.Map.Data.ScriptResources[targetrestype]);
|
|
|
|
// Determine starting resource
|
|
int startres = -1;
|
|
if(curtab is ScriptResourceDocumentTab)
|
|
{
|
|
startres = reslist.IndexOf(((ScriptResourceDocumentTab)curtab).Resource);
|
|
}
|
|
else if(curtab is ScriptLumpDocumentTab)
|
|
{
|
|
// Only temporary map wad qualifies
|
|
var scripttab = (ScriptLumpDocumentTab)curtab;
|
|
for(int i = 0; i < reslist.Count; i++)
|
|
{
|
|
if(reslist[i].Resource == General.Map.TemporaryMapFile && reslist[i].Filename == scripttab.Filename)
|
|
{
|
|
startres = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Search after current resource
|
|
// This will search among all resources of targetrestype when startres == -1
|
|
for(int i = startres + 1; i < reslist.Count; i++)
|
|
{
|
|
// Perform search...
|
|
if((!reslist[i].IsReadOnly || !replacemode) && reslist[i].ContainsText(ressearchoptions))
|
|
{
|
|
// Found it!
|
|
var newtab = OpenResource(reslist[i]);
|
|
newtab.FindNext(ressearchoptions); // Search again using actual tab...
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if(searchallresources)
|
|
{
|
|
// Search all script types after current ScriptType
|
|
var usedscripttypes = new List<ScriptType>(General.Map.Data.ScriptResources.Keys);
|
|
int startrestypepos = usedscripttypes.IndexOf(targetrestype);
|
|
for(int i = startrestypepos + 1; i < usedscripttypes.Count; i++)
|
|
{
|
|
foreach(ScriptResource sr in General.Map.Data.ScriptResources[usedscripttypes[i]])
|
|
{
|
|
// Perform search...
|
|
if((!sr.IsReadOnly || !replacemode) && sr.ContainsText(ressearchoptions))
|
|
{
|
|
// Found it!
|
|
var newtab = OpenResource(sr);
|
|
newtab.FindNext(ressearchoptions); // Search again using actual tab...
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Search all script types before current ScriptType
|
|
if(startrestypepos > 0)
|
|
{
|
|
for(int i = 0; i < startrestypepos; i++)
|
|
{
|
|
foreach(ScriptResource sr in General.Map.Data.ScriptResources[usedscripttypes[i]])
|
|
{
|
|
// Perform search...
|
|
if((!sr.IsReadOnly || !replacemode) && sr.ContainsText(ressearchoptions))
|
|
{
|
|
// Found it!
|
|
var newtab = OpenResource(sr);
|
|
newtab.FindNext(ressearchoptions); // Search again using actual tab...
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Search before current resource
|
|
if(startres > 0)
|
|
{
|
|
for(int i = 0; i < startres; i++)
|
|
{
|
|
// Perform search...
|
|
if((!reslist[i].IsReadOnly || !replacemode) && reslist[i].ContainsText(ressearchoptions))
|
|
{
|
|
// Found it!
|
|
var newtab = OpenResource(reslist[i]);
|
|
newtab.FindNext(ressearchoptions); // Search again using actual tab...
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
else if(searchallresources)
|
|
{
|
|
// Just search among all resources
|
|
var usedscripttypes = new List<ScriptType>(General.Map.Data.ScriptResources.Keys);
|
|
for(int i = 0; i < usedscripttypes.Count; i++)
|
|
{
|
|
foreach(ScriptResource sr in General.Map.Data.ScriptResources[usedscripttypes[i]])
|
|
{
|
|
// Perform search...
|
|
if((!sr.IsReadOnly || !replacemode) && sr.ContainsText(ressearchoptions))
|
|
{
|
|
// Found it!
|
|
var newtab = OpenResource(sr);
|
|
newtab.FindNext(ressearchoptions); // Search again using actual tab...
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// No dice
|
|
return false;
|
|
|
|
default: throw new NotImplementedException("Unknown FindReplaceSearchMode!");
|
|
}
|
|
}
|
|
|
|
//mxd
|
|
public bool FindPreviousWrapAround(FindReplaceOptions options)
|
|
{
|
|
var curtab = ActiveTab;
|
|
if(curtab == null) return false; // Boilerplate
|
|
switch(options.SearchMode)
|
|
{
|
|
case FindReplaceSearchMode.CURRENT_FILE: return false; // Let the tab handle wrap-around
|
|
|
|
case FindReplaceSearchMode.OPENED_TABS_CURRENT_SCRIPT_TYPE:
|
|
case FindReplaceSearchMode.OPENED_TABS_ALL_SCRIPT_TYPES:
|
|
ScriptType targettabtype = curtab.Config.ScriptType;
|
|
bool checktabtype = (options.SearchMode == FindReplaceSearchMode.OPENED_TABS_CURRENT_SCRIPT_TYPE);
|
|
|
|
// Search in processed tab only
|
|
var searchoptions = new FindReplaceOptions(options) { SearchMode = FindReplaceSearchMode.CURRENT_FILE };
|
|
|
|
// Find previous suitable tab...
|
|
int start = tabs.TabPages.IndexOf(curtab);
|
|
|
|
// Search before current tab
|
|
for(int i = start - 1; i > -1; i--)
|
|
{
|
|
var t = tabs.TabPages[i] as ScriptDocumentTab;
|
|
if(t != null && (!checktabtype || t.Config.ScriptType == targettabtype) && t.FindPrevious(searchoptions))
|
|
{
|
|
// Previous match found!
|
|
tabs.SelectTab(t);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Search after current tab
|
|
if(start < tabs.TabPages.Count - 1)
|
|
{
|
|
for(int i = tabs.TabPages.Count - 1; i > start; i--)
|
|
{
|
|
var t = tabs.TabPages[i] as ScriptDocumentTab;
|
|
if(t != null && (!checktabtype || t.Config.ScriptType == targettabtype) && t.FindPrevious(searchoptions))
|
|
{
|
|
// Previous match found!
|
|
tabs.SelectTab(t);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// No dice
|
|
return false;
|
|
|
|
case FindReplaceSearchMode.CURRENT_PROJECT_CURRENT_SCRIPT_TYPE:
|
|
case FindReplaceSearchMode.CURRENT_PROJECT_ALL_SCRIPT_TYPES:
|
|
ScriptType targetrestype = curtab.Config.ScriptType;
|
|
bool searchallresources = (options.SearchMode == FindReplaceSearchMode.CURRENT_PROJECT_ALL_SCRIPT_TYPES);
|
|
|
|
// Search in processed tab only
|
|
var ressearchoptions = new FindReplaceOptions(options) { SearchMode = FindReplaceSearchMode.CURRENT_FILE };
|
|
bool replacemode = (options.ReplaceWith != null);
|
|
|
|
// Find current resource, then search
|
|
if(General.Map.Data.ScriptResources.ContainsKey(targetrestype))
|
|
{
|
|
var reslist = new List<ScriptResource>(General.Map.Data.ScriptResources[targetrestype]);
|
|
|
|
// Determine starting resource
|
|
int startres = -1;
|
|
if(curtab is ScriptResourceDocumentTab)
|
|
{
|
|
startres = reslist.IndexOf(((ScriptResourceDocumentTab)curtab).Resource);
|
|
}
|
|
else if(curtab is ScriptLumpDocumentTab)
|
|
{
|
|
// Only temporary map wad qualifies
|
|
var scripttab = (ScriptLumpDocumentTab)curtab;
|
|
for(int i = 0; i < reslist.Count; i++)
|
|
{
|
|
if(reslist[i].Resource == General.Map.TemporaryMapFile && reslist[i].Filename == scripttab.Filename)
|
|
{
|
|
startres = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Search before current resource
|
|
// This will search among all resources of targetrestype when startres == -1
|
|
for(int i = startres - 1; i > -1; i--)
|
|
{
|
|
// Perform search...
|
|
if((!reslist[i].IsReadOnly || !replacemode) && reslist[i].ContainsText(ressearchoptions))
|
|
{
|
|
// Found it!
|
|
var newtab = OpenResource(reslist[i]);
|
|
newtab.FindPrevious(ressearchoptions); // Search again using actual tab...
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if(searchallresources)
|
|
{
|
|
// Search all script types before current ScriptType
|
|
var usedscripttypes = new List<ScriptType>(General.Map.Data.ScriptResources.Keys);
|
|
int startrestypepos = usedscripttypes.IndexOf(targetrestype);
|
|
for(int i = startrestypepos - 1; i > 0; i--)
|
|
{
|
|
foreach(ScriptResource sr in General.Map.Data.ScriptResources[usedscripttypes[i]])
|
|
{
|
|
// Perform search...
|
|
if((!sr.IsReadOnly || !replacemode) && sr.ContainsText(ressearchoptions))
|
|
{
|
|
// Found it!
|
|
var newtab = OpenResource(sr);
|
|
newtab.FindPrevious(ressearchoptions); // Search again using actual tab...
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Search all script types after current ScriptType
|
|
if(startrestypepos < usedscripttypes.Count)
|
|
{
|
|
for(int i = usedscripttypes.Count - 1; i > startrestypepos; i--)
|
|
{
|
|
foreach(ScriptResource sr in General.Map.Data.ScriptResources[usedscripttypes[i]])
|
|
{
|
|
// Perform search...
|
|
if((!sr.IsReadOnly || !replacemode) && sr.ContainsText(ressearchoptions))
|
|
{
|
|
// Found it!
|
|
var newtab = OpenResource(sr);
|
|
newtab.FindPrevious(ressearchoptions); // Search again using actual tab...
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Search after current resource
|
|
if(startres > 0)
|
|
{
|
|
for(int i = reslist.Count - 1; i > startres; i--)
|
|
{
|
|
// Perform search...
|
|
if((!reslist[i].IsReadOnly || !replacemode) && reslist[i].ContainsText(ressearchoptions))
|
|
{
|
|
// Found it!
|
|
var newtab = OpenResource(reslist[i]);
|
|
newtab.FindPrevious(ressearchoptions); // Search again using actual tab...
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
else if(searchallresources)
|
|
{
|
|
// Just search among all resources
|
|
var usedscripttypes = new List<ScriptType>(General.Map.Data.ScriptResources.Keys);
|
|
for(int i = usedscripttypes.Count - 1; i > -1; i--)
|
|
{
|
|
foreach(ScriptResource sr in General.Map.Data.ScriptResources[usedscripttypes[i]])
|
|
{
|
|
// Perform search...
|
|
if((!sr.IsReadOnly || !replacemode) && sr.ContainsText(ressearchoptions))
|
|
{
|
|
// Found it!
|
|
var newtab = OpenResource(sr);
|
|
newtab.FindPrevious(ressearchoptions); // Search again using actual tab...
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// No dice
|
|
return false;
|
|
|
|
default: throw new NotImplementedException("Unknown FindReplaceSearchMode!");
|
|
}
|
|
}
|
|
|
|
// Replace if possible
|
|
public bool Replace(FindReplaceOptions options)
|
|
{
|
|
ScriptDocumentTab curtab = ActiveTab; //mxd
|
|
if(!string.IsNullOrEmpty(options.FindText) && options.ReplaceWith != null && curtab != null && !curtab.IsReadOnly)
|
|
{
|
|
if(string.Compare(curtab.SelectedText, options.FindText, !options.CaseSensitive) == 0)
|
|
{
|
|
// Replace selection
|
|
curtab.ReplaceSelection(options.ReplaceWith);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//mxd
|
|
internal bool FindUsages()
|
|
{
|
|
ScriptDocumentTab t = ActiveTab;
|
|
if(t != null)
|
|
{
|
|
string text = t.Editor.Scintilla.GetWordFromPosition(t.Editor.Scintilla.SelectionStart);
|
|
if(string.IsNullOrEmpty(text))
|
|
{
|
|
DisplayStatus(ScriptStatusType.Warning, "Unable to get search query from the text cursor position!");
|
|
}
|
|
else
|
|
{
|
|
var options = new FindReplaceOptions
|
|
{
|
|
FindText = text,
|
|
SearchMode = FindReplaceSearchMode.CURRENT_PROJECT_CURRENT_SCRIPT_TYPE,
|
|
WholeWord = true,
|
|
CaseSensitive = t.Config.CaseSensitive
|
|
};
|
|
|
|
return FindUsages(options, t.Config.ScriptType);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DisplayStatus(ScriptStatusType.Warning, "An active tab is required to perform Find Usages action!");
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//mxd
|
|
public bool FindUsages(FindReplaceOptions options, ScriptType scripttype)
|
|
{
|
|
if(findusages.FindUsages(options, scripttype))
|
|
{
|
|
infotabs.SelectedTab = tabsearchresults;
|
|
scriptsplitter.IsCollapsed = false;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// This closed the Find & Replace subwindow
|
|
public void CloseFindReplace(bool closing)
|
|
{
|
|
if(findreplaceform != null)
|
|
{
|
|
if(!closing) findreplaceform.Close();
|
|
findreplaceform = null;
|
|
}
|
|
}
|
|
|
|
// This opens the Find & Replace subwindow
|
|
public void OpenFindAndReplace()
|
|
{
|
|
if(findreplaceform == null)
|
|
findreplaceform = new ScriptFindReplaceForm();
|
|
|
|
try
|
|
{
|
|
findreplaceform.CanReplace = !ActiveTab.IsReadOnly; //mxd
|
|
|
|
if(findreplaceform.Visible)
|
|
findreplaceform.Focus();
|
|
else
|
|
findreplaceform.Show(this.ParentForm);
|
|
|
|
if(ActiveTab.SelectionEnd != ActiveTab.SelectionStart)
|
|
findreplaceform.SetFindText(ActiveTab.SelectedText);
|
|
}
|
|
catch { } // If we can't pop up the find/replace form right now, thats just too bad.
|
|
}
|
|
|
|
//mxd
|
|
public void GoToLine()
|
|
{
|
|
if(ActiveTab == null) return;
|
|
|
|
var form = new ScriptGoToLineForm { LineNumber = ActiveTab.Editor.Scintilla.CurrentLine };
|
|
if(form.ShowDialog(this.parentform) == DialogResult.OK)
|
|
{
|
|
ActiveTab.MoveToLine(form.LineNumber - 1);
|
|
}
|
|
}
|
|
|
|
// This refreshes all settings
|
|
public void RefreshSettings()
|
|
{
|
|
foreach(ScriptDocumentTab t in tabs.TabPages)
|
|
{
|
|
t.RefreshSettings();
|
|
}
|
|
}
|
|
|
|
// This clears all error marks and hides the errors list
|
|
public void ClearErrors()
|
|
{
|
|
// Hide list
|
|
if(infotabs.SelectedTab == taberrors) scriptsplitter.IsCollapsed = true;
|
|
errorlist.Items.Clear();
|
|
|
|
// Clear marks
|
|
foreach(ScriptDocumentTab t in tabs.TabPages)
|
|
{
|
|
t.ClearMarks();
|
|
}
|
|
}
|
|
|
|
// This shows the errors panel with the given errors
|
|
// Also updates the scripts with markers for the given errors
|
|
public void ShowErrors(IEnumerable<CompilerError> errors, bool combine)
|
|
{
|
|
// Copy list
|
|
if(combine) //mxd
|
|
{
|
|
if(compilererrors == null) compilererrors = new List<CompilerError>();
|
|
if(errors != null)
|
|
{
|
|
// Combine 2 error lists...
|
|
foreach(CompilerError err in errors)
|
|
{
|
|
bool alreadyadded = false;
|
|
foreach(CompilerError compilererror in compilererrors)
|
|
{
|
|
if(compilererror.Equals(err))
|
|
{
|
|
alreadyadded = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(!alreadyadded) compilererrors.Add(err);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
compilererrors = (errors != null ? new List<CompilerError>(errors) : new List<CompilerError>());
|
|
}
|
|
|
|
// Fill list
|
|
errorlist.BeginUpdate();
|
|
errorlist.Items.Clear();
|
|
int listindex = 1;
|
|
foreach(CompilerError e in compilererrors)
|
|
{
|
|
ListViewItem ei = new ListViewItem(listindex.ToString());
|
|
ei.ImageIndex = 0;
|
|
ei.SubItems.Add(e.description);
|
|
string filename = (e.filename.StartsWith("?") ? e.filename.Replace("?", "") : Path.GetFileName(e.filename)); //mxd
|
|
string linenumber = (e.linenumber != CompilerError.NO_LINE_NUMBER ? " (line " + (e.linenumber + 1) + ")" : String.Empty); //mxd
|
|
ei.SubItems.Add(filename + linenumber);
|
|
ei.Tag = e;
|
|
errorlist.Items.Add(ei);
|
|
listindex++;
|
|
}
|
|
errorlist.EndUpdate();
|
|
|
|
// Show marks on scripts
|
|
foreach(ScriptDocumentTab t in tabs.TabPages)
|
|
{
|
|
t.MarkScriptErrors(compilererrors);
|
|
}
|
|
|
|
//mxd. Show/hide panel
|
|
if(errorlist.Items.Count > 0)
|
|
{
|
|
infotabs.SelectedTab = taberrors;
|
|
if(scriptsplitter.IsCollapsed) scriptsplitter.IsCollapsed = false; // biwa. Only toggle if it's not shown
|
|
}
|
|
else if(infotabs.SelectedTab == taberrors)
|
|
{
|
|
if(!scriptsplitter.IsCollapsed) scriptsplitter.IsCollapsed = true; // biwa. Only toggle if it's shown
|
|
}
|
|
}
|
|
|
|
//mxd
|
|
internal void ShowError(TextResourceErrorItem item)
|
|
{
|
|
// Resource exists?
|
|
DataReader dr = null;
|
|
|
|
// Resource is a temporary file?
|
|
if(item.ResourceLocation.StartsWith(General.Map.TempPath))
|
|
{
|
|
// Search in PK3-embedded wads only
|
|
foreach(DataReader reader in General.Map.Data.Containers)
|
|
{
|
|
if(!(reader is PK3Reader)) continue;
|
|
PK3Reader pkr = (PK3Reader)reader;
|
|
foreach(WADReader wadreader in pkr.Wads)
|
|
{
|
|
if(wadreader.Location.location == item.ResourceLocation)
|
|
{
|
|
dr = wadreader;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Search among resources
|
|
foreach(DataReader reader in General.Map.Data.Containers)
|
|
{
|
|
if(reader.Location.location == item.ResourceLocation)
|
|
{
|
|
dr = reader;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Target lump exists?
|
|
if(dr == null || !dr.FileExists(item.LumpName, item.LumpIndex)) return;
|
|
|
|
TextResourceData trd = new TextResourceData(dr, dr.LoadFile(item.LumpName, item.LumpIndex), item.LumpName, item.LumpIndex, false);
|
|
var targettab = OpenResource(new ScriptResource(trd, item.ScriptType));
|
|
|
|
if(targettab != null)
|
|
{
|
|
// Go to error line
|
|
if(item.LineNumber != CompilerError.NO_LINE_NUMBER) targettab.MoveToLine(item.LineNumber);
|
|
|
|
// Show in resources tree
|
|
scriptresources.SelectItem(item.ResourceLocation, item.LumpName, item.LumpIndex, item.ScriptType);
|
|
}
|
|
}
|
|
|
|
//mxd
|
|
/*internal void ShowError(TextFileErrorItem item)
|
|
{
|
|
// File exists?
|
|
ScriptDocumentTab targettab = OpenFile(item.Filename, item.ScriptType);
|
|
|
|
// Go to error line
|
|
if(targettab != null && item.LineNumber != CompilerError.NO_LINE_NUMBER)
|
|
targettab.MoveToLine(item.LineNumber);
|
|
}*/
|
|
|
|
// This writes all explicitly opened files to the configuration
|
|
public void WriteOpenFilesToConfiguration()
|
|
{
|
|
General.Map.Options.ScriptDocumentSettings.Clear(); //mxd
|
|
foreach(ScriptDocumentTab t in tabs.TabPages) //mxd
|
|
{
|
|
if(t is ScriptFileDocumentTab)
|
|
{
|
|
// Don't store tabs, which were never saved (this only happens when a new tab was created and no text
|
|
// was entered into it before closing the script editor)
|
|
if(t.ExplicitSave && !t.IsSaveAsRequired)
|
|
{
|
|
var settings = t.GetViewSettings();
|
|
General.Map.Options.ScriptDocumentSettings[settings.Filename] = settings;
|
|
}
|
|
}
|
|
else if(t is ScriptLumpDocumentTab || t is ScriptResourceDocumentTab)
|
|
{
|
|
var settings = t.GetViewSettings();
|
|
General.Map.Options.ScriptDocumentSettings[settings.Filename] = settings;
|
|
}
|
|
else
|
|
{
|
|
throw new NotImplementedException("Unknown ScriptDocumentTab type");
|
|
}
|
|
}
|
|
}
|
|
|
|
// This asks to save files and returns the result
|
|
public bool AskSaveAll()
|
|
{
|
|
foreach(ScriptDocumentTab t in tabs.TabPages)
|
|
{
|
|
if(t.ExplicitSave)
|
|
{
|
|
if(!CloseScript(t, true)) return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// This closes a script and returns true when closed
|
|
private bool CloseScript(ScriptDocumentTab t, bool saveonly)
|
|
{
|
|
if(t.IsChanged)
|
|
{
|
|
// Ask to save
|
|
DialogResult result = MessageBox.Show(this.ParentForm, "Do you want to save changes to " + t.Title + "?", "Close File", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);
|
|
switch(result)
|
|
{
|
|
case DialogResult.Yes:
|
|
if(!SaveScript(t)) return false;
|
|
break;
|
|
case DialogResult.Cancel:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if(!saveonly)
|
|
{
|
|
//mxd. Select tab to the left of the one we are going to close
|
|
if(t == tabs.SelectedTab && tabs.SelectedIndex > 0)
|
|
tabs.SelectedIndex--;
|
|
|
|
// Close file
|
|
tabs.TabPages.Remove(t);
|
|
t.Dispose();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// This returns true when any of the implicit-save scripts are changed
|
|
public bool CheckImplicitChanges()
|
|
{
|
|
foreach(ScriptDocumentTab t in tabs.TabPages)
|
|
{
|
|
if(!t.ExplicitSave && t.IsChanged) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// This forces the focus to the script editor
|
|
public void ForceFocus()
|
|
{
|
|
ScriptDocumentTab t = (tabs.SelectedTab as ScriptDocumentTab);
|
|
tabs.Focus();
|
|
if(t != null) t.Focus();
|
|
}
|
|
|
|
// This does an implicit save on all documents that use implicit saving
|
|
// Call this to save the lumps before disposing the panel!
|
|
public void ImplicitSave()
|
|
{
|
|
// Save all scripts
|
|
foreach(ScriptDocumentTab t in tabs.TabPages)
|
|
{
|
|
if(!t.ExplicitSave) t.Save();
|
|
}
|
|
|
|
UpdateInterface(false);
|
|
}
|
|
|
|
// This updates the toolbar for the current status
|
|
private void UpdateInterface(bool focuseditor)
|
|
{
|
|
int numscriptsopen = tabs.TabPages.Count;
|
|
int explicitsavescripts = 0;
|
|
ScriptDocumentTab t = null;
|
|
|
|
// Any explicit save scripts?
|
|
foreach(ScriptDocumentTab dt in tabs.TabPages)
|
|
if(dt.ExplicitSave && !dt.IsReadOnly) explicitsavescripts++;
|
|
|
|
// Get current script, if any are open
|
|
if(numscriptsopen > 0) t = (tabs.SelectedTab as ScriptDocumentTab);
|
|
|
|
// Enable/disable buttons
|
|
bool tabiseditable = (t != null && !t.IsReadOnly); //mxd
|
|
|
|
buttonsave.Enabled = (tabiseditable && t.ExplicitSave && t.IsChanged);
|
|
buttonsaveall.Enabled = (explicitsavescripts > 0);
|
|
buttoncompile.Enabled = (tabiseditable && t.Config.Compiler != null);
|
|
buttonsearch.Enabled = (t != null); //mxd
|
|
buttonkeywordhelp.Enabled = (t != null && !string.IsNullOrEmpty(t.Config.KeywordHelp));
|
|
buttonscriptconfig.Enabled = (tabiseditable && t.IsReconfigurable);
|
|
|
|
// Undo/Redo
|
|
buttonundo.Enabled = (tabiseditable && t.Editor.Scintilla.CanUndo);
|
|
buttonredo.Enabled = (tabiseditable && t.Editor.Scintilla.CanRedo);
|
|
|
|
// Cut/Copy/Paste
|
|
buttoncopy.Enabled = (t != null && t.Editor.Scintilla.SelectionStart < t.Editor.Scintilla.SelectionEnd);
|
|
buttoncut.Enabled = (tabiseditable && t.Editor.Scintilla.SelectionStart < t.Editor.Scintilla.SelectionEnd);
|
|
buttonpaste.Enabled = (tabiseditable && t.Editor.Scintilla.CanPaste);
|
|
|
|
//mxd. Snippets
|
|
buttonsnippets.DropDownItems.Clear();
|
|
menusnippets.DropDownItems.Clear();
|
|
|
|
bool havesnippets = (tabiseditable && t.Config.Snippets.Count > 0);
|
|
buttonsnippets.Enabled = havesnippets;
|
|
menusnippets.Enabled = havesnippets;
|
|
|
|
//mxd. Indent/Unindent
|
|
buttonindent.Enabled = tabiseditable;
|
|
buttonunindent.Enabled = (tabiseditable && t.Editor.Scintilla.Lines[t.Editor.Scintilla.CurrentLine].Indentation > 0);
|
|
|
|
//mxd. Whitespace
|
|
buttonwhitespace.Enabled = (t != null);
|
|
menuwhitespace.Enabled = (t != null);
|
|
|
|
//mxd. Wordwrap
|
|
buttonwordwrap.Enabled = (t != null);
|
|
menuwordwrap.Enabled = (t != null);
|
|
|
|
//mxd. Quick search options
|
|
searchmatchcase.Enabled = (t != null);
|
|
searchwholeword.Enabled = (t != null);
|
|
|
|
if(t != null)
|
|
{
|
|
//mxd. Update quick search controls
|
|
searchbox.Enabled = true;
|
|
if(searchbox.Text.Length > 0)
|
|
{
|
|
if(t.Editor.Scintilla.Text.IndexOf(searchbox.Text, searchmatchcase.Checked ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase) != -1)
|
|
{
|
|
searchprev.Enabled = true;
|
|
searchnext.Enabled = true;
|
|
searchbox.BackColor = SystemColors.Window;
|
|
}
|
|
else
|
|
{
|
|
searchprev.Enabled = false;
|
|
searchnext.Enabled = false;
|
|
searchbox.BackColor = QUICKSEARCH_FAIL_COLOR;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
searchprev.Enabled = false;
|
|
searchnext.Enabled = false;
|
|
}
|
|
|
|
// Check the according script config in menu
|
|
foreach(ToolStripMenuItem item in buttonscriptconfig.DropDownItems)
|
|
{
|
|
ScriptConfiguration config = (item.Tag as ScriptConfiguration);
|
|
item.Checked = (config == t.Config);
|
|
}
|
|
|
|
//mxd. Add snippets
|
|
if(t.Config != null && t.Config.Snippets.Count > 0)
|
|
{
|
|
if(t.Config.Snippets.Count > 0)
|
|
{
|
|
foreach(string snippetname in t.Config.Snippets)
|
|
{
|
|
buttonsnippets.DropDownItems.Add(snippetname).Click += OnInsertSnippetClick;
|
|
menusnippets.DropDownItems.Add(snippetname).Click += OnInsertSnippetClick;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Focus to script editor
|
|
if(focuseditor) ForceFocus();
|
|
}
|
|
else
|
|
{
|
|
//mxd. Disable quick search controls
|
|
searchbox.Enabled = false;
|
|
searchprev.Enabled = false;
|
|
searchnext.Enabled = false;
|
|
}
|
|
|
|
//mxd. Update script type description
|
|
scripttype.Text = ((t != null && t.Config != null) ? t.Config.Description : "Plain Text");
|
|
}
|
|
|
|
// This opens the given file, returns null when failed
|
|
public ScriptFileDocumentTab OpenFile(string filename, ScriptType scripttype)
|
|
{
|
|
//mxd. Check if we already have this file opened
|
|
foreach(var tab in tabs.TabPages)
|
|
{
|
|
if(!(tab is ScriptFileDocumentTab)) continue;
|
|
ScriptFileDocumentTab filetab = (ScriptFileDocumentTab)tab;
|
|
|
|
if(filetab.Filename == filename)
|
|
{
|
|
tabs.SelectedTab = filetab;
|
|
return filetab;
|
|
}
|
|
}
|
|
|
|
ScriptConfiguration foundconfig = new ScriptConfiguration();
|
|
|
|
// Find the most suitable script configuration to use
|
|
if(scripttype == ScriptType.UNKNOWN)
|
|
{
|
|
foreach(ScriptConfiguration cfg in scriptconfigs)
|
|
{
|
|
foreach(string ext in cfg.Extensions)
|
|
{
|
|
// Use this configuration if the extension matches
|
|
if(filename.EndsWith("." + ext, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
foundconfig = cfg;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
foundconfig = General.GetScriptConfiguration(scripttype);
|
|
}
|
|
|
|
// Create new document
|
|
ScriptFileDocumentTab t = new ScriptFileDocumentTab(this, foundconfig);
|
|
if(t.Open(filename))
|
|
{
|
|
//mxd. Try to determine script type from file contents...
|
|
if(scripttype == ScriptType.UNKNOWN)
|
|
{
|
|
ScriptType st = t.VerifyScriptType();
|
|
if(st != ScriptType.UNKNOWN)
|
|
{
|
|
foreach(ScriptConfiguration cfg in scriptconfigs)
|
|
{
|
|
if(cfg.ScriptType == st)
|
|
{
|
|
t.ChangeScriptConfig(cfg);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Mark any errors this script may have
|
|
if(compilererrors != null) t.MarkScriptErrors(compilererrors);
|
|
|
|
// Add to tabs
|
|
tabs.TabPages.Add(t);
|
|
tabs.SelectedTab = t;
|
|
|
|
// Done
|
|
t.OnTextChanged += tabpage_OnTextChanged; //mxd
|
|
t.Editor.Scintilla.UpdateUI += scintilla_OnUpdateUI;
|
|
UpdateInterface(true);
|
|
return t;
|
|
}
|
|
|
|
// Failed
|
|
return null;
|
|
}
|
|
|
|
//mxd
|
|
internal ScriptResourceDocumentTab OpenResource(ScriptResource resource)
|
|
{
|
|
// Check if we already have this file opened
|
|
foreach(var tab in tabs.TabPages)
|
|
{
|
|
if(!(tab is ScriptResourceDocumentTab)) continue;
|
|
ScriptResourceDocumentTab restab = (ScriptResourceDocumentTab)tab;
|
|
|
|
if(restab.Resource.LumpIndex == resource.LumpIndex && restab.Resource.FilePathName == resource.FilePathName)
|
|
{
|
|
tabs.SelectedTab = restab;
|
|
return restab;
|
|
}
|
|
}
|
|
|
|
// Create new document
|
|
ScriptConfiguration config = General.GetScriptConfiguration(resource.ScriptType);
|
|
if(config == null || config.ScriptType != resource.ScriptType)
|
|
{
|
|
General.ErrorLogger.Add(ErrorType.Warning, "Incorrect or missing script configuration for \"" + resource.ScriptType + "\" script type. Using plain text configuration.");
|
|
config = new ScriptConfiguration();
|
|
}
|
|
|
|
var t = new ScriptResourceDocumentTab(this, resource, config);
|
|
|
|
// Mark any errors this script may have
|
|
if(compilererrors != null) t.MarkScriptErrors(compilererrors);
|
|
|
|
// Add to tabs
|
|
tabs.TabPages.Add(t);
|
|
tabs.SelectedTab = t;
|
|
|
|
// Done
|
|
t.OnTextChanged += tabpage_OnTextChanged;
|
|
t.Editor.Scintilla.UpdateUI += scintilla_OnUpdateUI;
|
|
UpdateInterface(true);
|
|
return t;
|
|
}
|
|
|
|
// This saves the current open script
|
|
public void ExplicitSaveCurrentTab()
|
|
{
|
|
ScriptDocumentTab t = (tabs.SelectedTab as ScriptDocumentTab);
|
|
if((t != null))
|
|
{
|
|
if(t.ExplicitSave)
|
|
buttonsave_Click(this, EventArgs.Empty);
|
|
else if(t.Config.Compiler != null) //mxd
|
|
buttoncompile_Click(this, EventArgs.Empty);
|
|
else
|
|
General.MessageBeep(MessageBeepType.Default);
|
|
}
|
|
else
|
|
{
|
|
General.MessageBeep(MessageBeepType.Default);
|
|
}
|
|
}
|
|
|
|
// This opens a script
|
|
public void OpenBrowseScript()
|
|
{
|
|
buttonopen_Click(this, EventArgs.Empty);
|
|
}
|
|
|
|
//mxd. This launches keyword help website
|
|
public bool LaunchKeywordHelp()
|
|
{
|
|
// Get script
|
|
ScriptDocumentTab t = (tabs.SelectedTab as ScriptDocumentTab);
|
|
return (t != null && t.LaunchKeywordHelp());
|
|
}
|
|
|
|
//mxd. This changes status text
|
|
internal void DisplayStatus(ScriptStatusType type, string message) { DisplayStatus(new ScriptStatusInfo(type, message)); }
|
|
internal void DisplayStatus(ScriptStatusInfo newstatus)
|
|
{
|
|
// Stop timers
|
|
if(!newstatus.displayed)
|
|
{
|
|
statusresetter.Stop();
|
|
statusflasher.Stop();
|
|
statusflashicon = false;
|
|
}
|
|
|
|
// Determine what to do specifically for this status type
|
|
switch(newstatus.type)
|
|
{
|
|
// Shows information without flashing the icon.
|
|
case ScriptStatusType.Ready:
|
|
case ScriptStatusType.Info:
|
|
if(!newstatus.displayed)
|
|
{
|
|
statusresetter.Interval = MainForm.INFO_RESET_DELAY;
|
|
statusresetter.Start();
|
|
}
|
|
break;
|
|
|
|
// Shows a warning, makes a warning sound and flashes a warning icon.
|
|
case ScriptStatusType.Warning:
|
|
if(!newstatus.displayed)
|
|
{
|
|
General.MessageBeep(MessageBeepType.Warning);
|
|
statusflasher.Interval = MainForm.WARNING_FLASH_INTERVAL;
|
|
statusflashcount = MainForm.WARNING_FLASH_COUNT;
|
|
statusflasher.Start();
|
|
statusresetter.Interval = MainForm.WARNING_RESET_DELAY;
|
|
statusresetter.Start();
|
|
}
|
|
break;
|
|
}
|
|
|
|
// Update status description
|
|
status = newstatus;
|
|
status.displayed = true;
|
|
statuslabel.Text = status.message;
|
|
|
|
// Update icon as well
|
|
UpdateStatusIcon();
|
|
|
|
// Refresh
|
|
statusbar.Invalidate();
|
|
this.Update();
|
|
}
|
|
|
|
// This updates the status icon
|
|
private void UpdateStatusIcon()
|
|
{
|
|
int statusflashindex = (statusflashicon ? 1 : 0);
|
|
|
|
// Status type
|
|
switch(status.type)
|
|
{
|
|
case ScriptStatusType.Ready:
|
|
case ScriptStatusType.Info:
|
|
statuslabel.Image = General.MainWindow.STATUS_IMAGES[statusflashindex, 0];
|
|
break;
|
|
|
|
case ScriptStatusType.Busy:
|
|
statuslabel.Image = General.MainWindow.STATUS_IMAGES[statusflashindex, 2];
|
|
break;
|
|
|
|
case ScriptStatusType.Warning:
|
|
statuslabel.Image = General.MainWindow.STATUS_IMAGES[statusflashindex, 3];
|
|
break;
|
|
|
|
default:
|
|
throw new NotImplementedException("Unsupported Script Status Type!");
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Events
|
|
|
|
// Called when the window that contains this panel closes
|
|
public void OnClose()
|
|
{
|
|
//mxd. Store quick search settings
|
|
matchcase = searchmatchcase.Checked;
|
|
matchwholeword = searchwholeword.Checked;
|
|
|
|
//mxd. Stop status timers
|
|
statusresetter.Stop();
|
|
statusflasher.Stop();
|
|
|
|
//mxd
|
|
findusages.OnClose();
|
|
|
|
// Close the sub windows now
|
|
if(findreplaceform != null) findreplaceform.Dispose();
|
|
}
|
|
|
|
// Keyword help requested
|
|
private void buttonkeywordhelp_Click(object sender, EventArgs e)
|
|
{
|
|
LaunchKeywordHelp();
|
|
}
|
|
|
|
// When the user changes the script configuration
|
|
private void buttonscriptconfig_Click(object sender, EventArgs e)
|
|
{
|
|
// Get the tab and new script config
|
|
ScriptDocumentTab t = (tabs.SelectedTab as ScriptDocumentTab);
|
|
ScriptConfiguration scriptconfig = ((sender as ToolStripMenuItem).Tag as ScriptConfiguration);
|
|
|
|
// Change script config
|
|
t.ChangeScriptConfig(scriptconfig);
|
|
|
|
//mxd. Update script type description
|
|
scripttype.Text = scriptconfig.Description;
|
|
|
|
// Done
|
|
UpdateInterface(true);
|
|
}
|
|
|
|
// When new script is clicked
|
|
private void buttonnew_Click(object sender, EventArgs e)
|
|
{
|
|
// Get the script config to use
|
|
ScriptConfiguration scriptconfig = ((sender as ToolStripMenuItem).Tag as ScriptConfiguration);
|
|
|
|
// Create new document
|
|
ScriptFileDocumentTab t = new ScriptFileDocumentTab(this, scriptconfig);
|
|
tabs.TabPages.Add(t);
|
|
tabs.SelectedTab = t;
|
|
|
|
// Done
|
|
UpdateInterface(true);
|
|
}
|
|
|
|
// Open script clicked
|
|
private void buttonopen_Click(object sender, EventArgs e)
|
|
{
|
|
// Show open file dialog
|
|
if(openfile.ShowDialog(this.ParentForm) == DialogResult.OK)
|
|
{
|
|
//mxd. Gather already opened file names
|
|
List<string> openedfiles = new List<string>();
|
|
foreach(var page in tabs.TabPages)
|
|
{
|
|
var scriptpage = page as ScriptFileDocumentTab;
|
|
if(scriptpage != null) openedfiles.Add(scriptpage.Filename);
|
|
}
|
|
|
|
//mxd. Add new tabs
|
|
foreach(string name in openfile.FileNames)
|
|
{
|
|
if(!openedfiles.Contains(name))
|
|
{
|
|
ScriptFileDocumentTab t = OpenFile(name, ScriptType.UNKNOWN);
|
|
|
|
// Apply document settings
|
|
if(General.Map.Options.ScriptDocumentSettings.ContainsKey(t.Filename))
|
|
{
|
|
t.SetViewSettings(General.Map.Options.ScriptDocumentSettings[t.Filename]);
|
|
}
|
|
else
|
|
{
|
|
// Apply default settings
|
|
t.SetDefaultViewSettings();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Select the last new item
|
|
foreach(var page in tabs.TabPages)
|
|
{
|
|
var scriptpage = page as ScriptFileDocumentTab;
|
|
if(scriptpage != null && scriptpage.Filename == openfile.FileNames[openfile.FileNames.Length - 1])
|
|
{
|
|
tabs.SelectedTab = scriptpage;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Save script clicked
|
|
private void buttonsave_Click(object sender, EventArgs e)
|
|
{
|
|
// Save the current script
|
|
ScriptDocumentTab t = (tabs.SelectedTab as ScriptDocumentTab);
|
|
SaveScript(t);
|
|
UpdateInterface(true);
|
|
}
|
|
|
|
// Save All clicked
|
|
private void buttonsaveall_Click(object sender, EventArgs e)
|
|
{
|
|
// Save all scripts
|
|
foreach(ScriptDocumentTab t in tabs.TabPages)
|
|
{
|
|
// Use explicit save for this script?
|
|
if(t.ExplicitSave)
|
|
{
|
|
if(!SaveScript(t)) break;
|
|
}
|
|
}
|
|
|
|
UpdateInterface(true);
|
|
}
|
|
|
|
// This is called by Save and Save All to save a script
|
|
// Returns false when cancelled by the user
|
|
private bool SaveScript(ScriptDocumentTab t)
|
|
{
|
|
// Do we have to do a save as?
|
|
if(t.IsSaveAsRequired)
|
|
{
|
|
// Setup save dialog
|
|
string scriptfilter = t.Config.Description + "|*." + string.Join(";*.", t.Config.Extensions);
|
|
savefile.Filter = scriptfilter + "|All files|*.*";
|
|
if(savefile.ShowDialog(this.ParentForm) == DialogResult.OK)
|
|
{
|
|
// Save to new filename
|
|
t.SaveAs(savefile.FileName);
|
|
|
|
//mxd. Also compile if needed
|
|
if(t.Config.Compiler != null) t.Compile();
|
|
|
|
return true;
|
|
}
|
|
|
|
// Cancelled
|
|
return false;
|
|
}
|
|
|
|
// Save to same filename
|
|
t.Save();
|
|
|
|
return true;
|
|
}
|
|
|
|
// A tab is selected
|
|
private void tabs_Selecting(object sender, TabControlCancelEventArgs e)
|
|
{
|
|
//mxd. Update script navigator
|
|
ScriptDocumentTab tab = e.TabPage as ScriptDocumentTab;
|
|
if(tab != null)
|
|
{
|
|
// Show all errors...
|
|
ShowErrors(tab.UpdateNavigator(), true);
|
|
}
|
|
|
|
UpdateInterface(true);
|
|
}
|
|
|
|
// Compile Script clicked
|
|
private void buttoncompile_Click(object sender, EventArgs e)
|
|
{
|
|
// First save all implicit scripts to the temporary wad file
|
|
ImplicitSave();
|
|
|
|
// Get script
|
|
ScriptDocumentTab t = (tabs.SelectedTab as ScriptDocumentTab);
|
|
|
|
// Check if it must be saved as a new file
|
|
if(t.ExplicitSave && t.IsSaveAsRequired)
|
|
{
|
|
// Save the script first!
|
|
if(MessageBox.Show(this.ParentForm, "You must save your script before you can compile it. Do you want to save your script now?", "Compile Script", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.Yes)
|
|
{
|
|
if(!SaveScript(t)) return;
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
else if(t.ExplicitSave && t.IsChanged)
|
|
{
|
|
// We can only compile when the script is saved
|
|
if(!SaveScript(t)) return;
|
|
}
|
|
|
|
// Compile now
|
|
DisplayStatus(ScriptStatusType.Busy, "Compiling script \"" + t.Title + "\"...");
|
|
Cursor.Current = Cursors.WaitCursor;
|
|
t.Compile();
|
|
|
|
// Show warning
|
|
if((compilererrors != null) && (compilererrors.Count > 0))
|
|
DisplayStatus(ScriptStatusType.Warning, compilererrors.Count + " errors while compiling \"" + t.Title + "\"!");
|
|
else
|
|
DisplayStatus(ScriptStatusType.Info, "Script \"" + t.Title + "\" compiled without errors.");
|
|
|
|
Cursor.Current = Cursors.Default;
|
|
UpdateInterface(true);
|
|
}
|
|
|
|
// Undo clicked
|
|
private void buttonundo_Click(object sender, EventArgs e)
|
|
{
|
|
//mxd. Special cases...
|
|
if(searchbox.Focused)
|
|
{
|
|
searchbox.Undo();
|
|
return;
|
|
}
|
|
|
|
ScriptDocumentTab t = (tabs.SelectedTab as ScriptDocumentTab);
|
|
t.Undo();
|
|
UpdateInterface(true);
|
|
}
|
|
|
|
// Redo clicked
|
|
private void buttonredo_Click(object sender, EventArgs e)
|
|
{
|
|
//mxd. Special cases...
|
|
if(searchbox.Focused)
|
|
{
|
|
searchbox.Undo();
|
|
return;
|
|
}
|
|
|
|
ScriptDocumentTab t = (tabs.SelectedTab as ScriptDocumentTab);
|
|
t.Redo();
|
|
UpdateInterface(true);
|
|
}
|
|
|
|
// Cut clicked
|
|
private void buttoncut_Click(object sender, EventArgs e)
|
|
{
|
|
//mxd. Special cases...
|
|
if(searchbox.Focused)
|
|
{
|
|
if(searchbox.TextBox != null) searchbox.TextBox.Cut();
|
|
return;
|
|
}
|
|
|
|
ScriptDocumentTab t = (tabs.SelectedTab as ScriptDocumentTab);
|
|
t.Cut();
|
|
UpdateInterface(true);
|
|
}
|
|
|
|
// Copy clicked
|
|
private void buttoncopy_Click(object sender, EventArgs e)
|
|
{
|
|
//mxd. Special cases...
|
|
if(searchbox.Focused)
|
|
{
|
|
searchbox.Copy();
|
|
return;
|
|
}
|
|
|
|
ScriptDocumentTab t = (tabs.SelectedTab as ScriptDocumentTab);
|
|
t.Copy();
|
|
UpdateInterface(true);
|
|
}
|
|
|
|
// Paste clicked
|
|
private void buttonpaste_Click(object sender, EventArgs e)
|
|
{
|
|
//mxd. Special cases...
|
|
if(searchbox.Focused)
|
|
{
|
|
searchbox.Paste();
|
|
return;
|
|
}
|
|
|
|
ScriptDocumentTab t = (tabs.SelectedTab as ScriptDocumentTab);
|
|
t.Paste();
|
|
UpdateInterface(true);
|
|
}
|
|
|
|
//mxd
|
|
private void buttonunindent_Click(object sender, EventArgs e)
|
|
{
|
|
ScriptDocumentTab t = (tabs.SelectedTab as ScriptDocumentTab);
|
|
t.IndentSelection(false);
|
|
}
|
|
|
|
//mxd
|
|
private void buttonindent_Click(object sender, EventArgs e)
|
|
{
|
|
ScriptDocumentTab t = (tabs.SelectedTab as ScriptDocumentTab);
|
|
t.IndentSelection(true);
|
|
}
|
|
|
|
//mxd
|
|
private void buttonwhitespace_Click(object sender, EventArgs e)
|
|
{
|
|
if(blockupdate) return;
|
|
|
|
blockupdate = true;
|
|
showwhitespace = !showwhitespace;
|
|
buttonwhitespace.Checked = showwhitespace;
|
|
menuwhitespace.Checked = showwhitespace;
|
|
blockupdate = false;
|
|
|
|
ApplyTabSettings();
|
|
}
|
|
|
|
//mxd
|
|
private void buttonwordwrap_Click(object sender, EventArgs e)
|
|
{
|
|
if(blockupdate) return;
|
|
|
|
blockupdate = true;
|
|
wraplonglines = !wraplonglines;
|
|
buttonwordwrap.Checked = wraplonglines;
|
|
menuwordwrap.Checked = wraplonglines;
|
|
blockupdate = false;
|
|
|
|
ApplyTabSettings();
|
|
}
|
|
|
|
//mxd. Search clicked
|
|
private void buttonsearch_Click(object sender, EventArgs e)
|
|
{
|
|
OpenFindAndReplace();
|
|
}
|
|
|
|
//mxd
|
|
private void menugotoline_Click(object sender, EventArgs e)
|
|
{
|
|
GoToLine();
|
|
}
|
|
|
|
//mxd
|
|
private void menuduplicateline_Click(object sender, EventArgs e)
|
|
{
|
|
if(ActiveTab != null) ActiveTab.Editor.DuplicateLine();
|
|
}
|
|
|
|
//mxd
|
|
private void menustayontop_Click(object sender, EventArgs e)
|
|
{
|
|
General.Settings.ScriptOnTop = menustayontop.Checked;
|
|
parentform.TopMost = General.Settings.ScriptOnTop;
|
|
}
|
|
|
|
//mxd
|
|
private void OnInsertSnippetClick(object sender, EventArgs eventArgs)
|
|
{
|
|
ScriptDocumentTab t = (tabs.SelectedTab as ScriptDocumentTab);
|
|
t.InsertSnippet( ((ToolStripItem)sender).Text );
|
|
}
|
|
|
|
// Mouse released on tabs
|
|
private void tabs_MouseUp(object sender, MouseEventArgs e)
|
|
{
|
|
ForceFocus();
|
|
}
|
|
|
|
//mxd
|
|
private void tabs_MouseDoubleClick(object sender, MouseEventArgs e)
|
|
{
|
|
// Show corresponding resource
|
|
scriptresources.SelectItem(tabs.SelectedTab as ScriptResourceDocumentTab);
|
|
}
|
|
|
|
//mxd
|
|
private void tabs_OnCloseTabClicked(object sender, TabControlEventArgs e)
|
|
{
|
|
ScriptDocumentTab t = (e.TabPage as ScriptDocumentTab);
|
|
|
|
//TODO: allow any tab to be closed.
|
|
if(!t.IsClosable) return;
|
|
|
|
CloseScript(t, false);
|
|
UpdateInterface(true);
|
|
}
|
|
|
|
//mxd. Text in ScriptFileDocumentTab was changed
|
|
private void tabpage_OnTextChanged(object sender, EventArgs eventArgs)
|
|
{
|
|
if(tabs.SelectedTab != null)
|
|
{
|
|
ScriptDocumentTab curtab = tabs.SelectedTab as ScriptDocumentTab;
|
|
if(curtab != null)
|
|
{
|
|
buttonsave.Enabled = (curtab.ExplicitSave && curtab.IsChanged);
|
|
buttonundo.Enabled = curtab.Editor.Scintilla.CanUndo;
|
|
buttonredo.Enabled = curtab.Editor.Scintilla.CanRedo;
|
|
}
|
|
}
|
|
}
|
|
|
|
//mxd. Text in ScriptLumpDocumentTab was changed
|
|
private void tabpage_OnLumpTextChanged(object sender, EventArgs e)
|
|
{
|
|
if(tabs.SelectedTab != null)
|
|
{
|
|
ScriptDocumentTab curtab = tabs.SelectedTab as ScriptDocumentTab;
|
|
if(curtab != null)
|
|
{
|
|
buttonundo.Enabled = curtab.Editor.Scintilla.CanUndo;
|
|
buttonredo.Enabled = curtab.Editor.Scintilla.CanRedo;
|
|
}
|
|
}
|
|
}
|
|
|
|
//mxd
|
|
private void scintilla_OnUpdateUI(object sender, UpdateUIEventArgs e)
|
|
{
|
|
Scintilla s = sender as Scintilla;
|
|
if(s != null)
|
|
{
|
|
// Update caret position info [line] : [caret pos start] OR [caret pos start x selection length] ([total lines])
|
|
positionlabel.Text = (s.CurrentLine + 1) + " : "
|
|
+ (s.SelectionStart + 1 - s.Lines[s.LineFromPosition(s.SelectionStart)].Position)
|
|
+ (s.SelectionStart != s.SelectionEnd ? "x" + (s.SelectionEnd - s.SelectionStart) : "")
|
|
+ " (" + s.Lines.Count + ")";
|
|
|
|
// Update copy-paste buttons
|
|
buttoncut.Enabled = (s.SelectionEnd > s.SelectionStart);
|
|
buttoncopy.Enabled = (s.SelectionEnd > s.SelectionStart);
|
|
buttonpaste.Enabled = s.CanPaste;
|
|
buttonunindent.Enabled = s.Lines[s.CurrentLine].Indentation > 0;
|
|
}
|
|
}
|
|
|
|
// User double-clicks and error in the list
|
|
private void errorlist_ItemActivate(object sender, EventArgs e)
|
|
{
|
|
// Anything selection?
|
|
if(errorlist.SelectedItems.Count > 0)
|
|
{
|
|
// Get the compiler error
|
|
CompilerError err = (CompilerError)errorlist.SelectedItems[0].Tag;
|
|
|
|
// Show the tab with the script that matches
|
|
bool foundscript = false;
|
|
foreach(ScriptDocumentTab t in tabs.TabPages)
|
|
{
|
|
if(t.VerifyErrorForScript(err))
|
|
{
|
|
tabs.SelectedTab = t;
|
|
t.MoveToLine(err.linenumber);
|
|
foundscript = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If we don't have the script opened, see if we can find the file and open the script
|
|
if(!foundscript && File.Exists(err.filename))
|
|
{
|
|
ScriptDocumentTab t = OpenFile(err.filename, ScriptType.UNKNOWN);
|
|
if(t != null) t.MoveToLine(err.linenumber);
|
|
}
|
|
|
|
ForceFocus();
|
|
}
|
|
}
|
|
|
|
private void menufindusages_Click(object sender, EventArgs e)
|
|
{
|
|
FindUsages();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Quick Search (mxd)
|
|
|
|
private FindReplaceOptions GetQuickSearchOptions()
|
|
{
|
|
return new FindReplaceOptions
|
|
{
|
|
CaseSensitive = searchmatchcase.Checked,
|
|
WholeWord = searchwholeword.Checked,
|
|
FindText = searchbox.Text
|
|
};
|
|
}
|
|
|
|
private void searchbox_TextChanged(object sender, EventArgs e)
|
|
{
|
|
bool success = (searchbox.Text.Length > 0 && ActiveTab.FindNext(GetQuickSearchOptions(), true));
|
|
searchbox.BackColor = ((success || searchbox.Text.Length == 0) ? SystemColors.Window : QUICKSEARCH_FAIL_COLOR);
|
|
searchnext.Enabled = success;
|
|
searchprev.Enabled = success;
|
|
}
|
|
|
|
private void searchnext_Click(object sender, EventArgs e)
|
|
{
|
|
if(!ActiveTab.FindNext(GetQuickSearchOptions(), false)) General.MessageBeep(MessageBeepType.Default);
|
|
}
|
|
|
|
private void searchprev_Click(object sender, EventArgs e)
|
|
{
|
|
if(!ActiveTab.FindPrevious(GetQuickSearchOptions())) General.MessageBeep(MessageBeepType.Default);
|
|
}
|
|
|
|
// This flashes the status icon
|
|
private void statusflasher_Tick(object sender, EventArgs e)
|
|
{
|
|
statusflashicon = !statusflashicon;
|
|
UpdateStatusIcon();
|
|
statusflashcount--;
|
|
if(statusflashcount == 0) statusflasher.Stop();
|
|
}
|
|
|
|
// This resets the status to ready
|
|
private void statusresetter_Tick(object sender, EventArgs e)
|
|
{
|
|
DisplayStatus(ScriptStatusType.Ready, null);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Menu opening events (mxd)
|
|
|
|
private void filemenuitem_DropDownOpening(object sender, EventArgs e)
|
|
{
|
|
ScriptDocumentTab t = ActiveTab;
|
|
menusave.Enabled = (t != null && !t.IsReadOnly && t.ExplicitSave && t.IsChanged);
|
|
|
|
// Any explicit save scripts?
|
|
int explicitsavescripts = 0;
|
|
foreach(ScriptDocumentTab dt in tabs.TabPages)
|
|
if(dt.ExplicitSave && !dt.IsReadOnly) explicitsavescripts++;
|
|
|
|
menusaveall.Enabled = (explicitsavescripts > 0);
|
|
}
|
|
|
|
private void editmenuitem_DropDownOpening(object sender, EventArgs e)
|
|
{
|
|
ScriptDocumentTab t = ActiveTab;
|
|
if(t != null)
|
|
{
|
|
Scintilla s = t.Editor.Scintilla;
|
|
|
|
menuundo.Enabled = s.CanUndo;
|
|
menuredo.Enabled = s.CanRedo;
|
|
|
|
menucut.Enabled = (s.SelectionEnd > s.SelectionStart);
|
|
menucopy.Enabled = (s.SelectionEnd > s.SelectionStart);
|
|
menupaste.Enabled = s.CanPaste;
|
|
|
|
menuindent.Enabled = true;
|
|
menuunindent.Enabled = s.Lines[s.CurrentLine].Indentation > 0;
|
|
|
|
menugotoline.Enabled = true;
|
|
menuduplicateline.Enabled = true;
|
|
}
|
|
else
|
|
{
|
|
menuundo.Enabled = false;
|
|
menuredo.Enabled = false;
|
|
|
|
menucut.Enabled = false;
|
|
menucopy.Enabled = false;
|
|
menupaste.Enabled = false;
|
|
|
|
menusnippets.Enabled = false;
|
|
|
|
menuindent.Enabled = false;
|
|
menuunindent.Enabled = false;
|
|
|
|
menugotoline.Enabled = false;
|
|
menuduplicateline.Enabled = false;
|
|
}
|
|
}
|
|
|
|
private void searchmenuitem_DropDownOpening(object sender, EventArgs e)
|
|
{
|
|
ScriptDocumentTab t = ActiveTab;
|
|
menufind.Enabled = (t != null);
|
|
menufindusages.Enabled = (t != null);
|
|
|
|
bool enable = (!string.IsNullOrEmpty(findoptions.FindText) && t != null);
|
|
menufindnext.Enabled = enable;
|
|
menufindprevious.Enabled = enable;
|
|
}
|
|
|
|
private void toolsmenu_DropDownOpening(object sender, EventArgs e)
|
|
{
|
|
ScriptDocumentTab t = ActiveTab;
|
|
menucompile.Enabled = (ActiveTab != null && !t.IsReadOnly && t.Config.Compiler != null);
|
|
}
|
|
|
|
#endregion
|
|
|
|
private void ScriptEditorPanel_Load(object sender, EventArgs e)
|
|
{
|
|
// biwa. The designer is setting the properties in the wrong order, which
|
|
// results in them not being set correctly at all. Set them here manually
|
|
// scriptsplitter.SplitterDistance = 100;
|
|
scriptsplitter.Panel1MinSize = 100;
|
|
scriptsplitter.Panel2MinSize = 100;
|
|
scriptsplitter.SetSizes();
|
|
|
|
mainsplitter.Panel1MinSize = 180;
|
|
mainsplitter.SetSizes();
|
|
}
|
|
}
|
|
}
|