mirror of
https://git.do.srb2.org/STJr/UltimateZoneBuilder.git
synced 2024-12-11 12:51:20 +00:00
486 lines
14 KiB
C#
Executable file
486 lines
14 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.Globalization;
|
|
using System.Windows.Forms;
|
|
using CodeImp.DoomBuilder.Config;
|
|
using System.Drawing;
|
|
|
|
#endregion
|
|
|
|
namespace CodeImp.DoomBuilder.Windows
|
|
{
|
|
internal partial class ActionBrowserForm : DelayedForm
|
|
{
|
|
// Constants
|
|
private const int MAX_OPTIONS = 8;
|
|
|
|
// Variables
|
|
private int selectedaction;
|
|
private readonly ComboBox[] options;
|
|
private readonly Label[] optionlbls;
|
|
private readonly TreeNode[] allNodes; //mxd
|
|
private readonly bool addanyaction; //mxd
|
|
private int actionidmaxdigits;
|
|
|
|
// Properties
|
|
public int SelectedAction { get { return selectedaction; } }
|
|
|
|
// Constructor
|
|
public ActionBrowserForm(int action, bool addanyaction)
|
|
{
|
|
// Initialize
|
|
InitializeComponent();
|
|
|
|
//mxd. Show "Any action" item?
|
|
this.addanyaction = addanyaction;
|
|
|
|
// Make array references for controls
|
|
options = new[] { option0, option1, option2, option3, option4, option5, option6, option7 };
|
|
optionlbls = new[] { option0label, option1label, option2label, option3label, option4label,
|
|
option5label, option6label, option7label };
|
|
|
|
// Show prefixes panel only for doom type maps
|
|
if(!General.Map.FormatInterface.HasBuiltInActivations)
|
|
{
|
|
prefixespanel.Visible = false;
|
|
actions.Height += prefixespanel.Height + 3; //mxd
|
|
}
|
|
|
|
// Go for all predefined categories
|
|
CreateActionCategories(action);
|
|
allNodes = new TreeNode[actions.Nodes.Count];
|
|
actions.Nodes.CopyTo(allNodes, 0);
|
|
|
|
// Using generalized actions?
|
|
if(General.Map.Config.GeneralizedActions)
|
|
{
|
|
// Add for all generalized categories to the combobox
|
|
category.Items.AddRange(General.Map.Config.GenActionCategories.ToArray());
|
|
|
|
// Given action is generalized?
|
|
if(GameConfiguration.IsGeneralized(action, General.Map.Config.GenActionCategories))
|
|
{
|
|
// Open the generalized tab
|
|
tabs.SelectedTab = tabgeneralized;
|
|
|
|
// Select category
|
|
foreach(GeneralizedCategory ac in category.Items)
|
|
{
|
|
if((action >= ac.Offset) && (action < (ac.Offset + ac.Length)))
|
|
{
|
|
category.SelectedItem = ac;
|
|
break; //mxd
|
|
}
|
|
}
|
|
|
|
// Anything selected?
|
|
if(category.SelectedIndex > -1)
|
|
{
|
|
// Go for all options in selected category
|
|
GeneralizedCategory sc = category.SelectedItem as GeneralizedCategory;
|
|
int actionbits = action - sc.Offset;
|
|
|
|
// Go for all options, bigger steps first (mxd)
|
|
// INFO: both GeneralizedOptions and GeneralizedBits are incrimentally sorted
|
|
for(int i = MAX_OPTIONS - 1; i > -1; i--)
|
|
{
|
|
// Option used?
|
|
if(i < sc.Options.Count)
|
|
{
|
|
// Go for all bits, bigger bits first (mxd)
|
|
for(int b = sc.Options[i].Bits.Count - 1; b > -1; b--)
|
|
{
|
|
// Select this setting if matches
|
|
GeneralizedBit bit = sc.Options[i].Bits[b];
|
|
if((actionbits & bit.Index) == bit.Index)
|
|
{
|
|
options[i].SelectedItem = bit;
|
|
actionbits -= bit.Index; //mxd
|
|
if(bit.Index > 0) break; //mxd
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//mxd. Make sure something is selected
|
|
if(category.SelectedIndex == -1 && category.Items.Count > 0)
|
|
category.SelectedIndex = 0;
|
|
}
|
|
else
|
|
{
|
|
// Remove generalized tab
|
|
tabs.TabPages.Remove(tabgeneralized);
|
|
}
|
|
|
|
// [ZZ] we are drawing nodes manually. we need nice number padding.
|
|
actions.DrawMode = TreeViewDrawMode.OwnerDrawText;
|
|
actions.DrawNode += Actions_DrawNode;
|
|
}
|
|
|
|
private void Actions_DrawNode(object sender, DrawTreeNodeEventArgs e)
|
|
{
|
|
Rectangle nodeRect = Rectangle.FromLTRB(e.Bounds.Left + 1, e.Bounds.Top, e.Bounds.Right + 1, e.Bounds.Bottom);
|
|
Rectangle nodeTextRect = Rectangle.FromLTRB(nodeRect.Left, nodeRect.Top + 1, nodeRect.Right, nodeRect.Bottom);
|
|
string nodeText = e.Node.Text;
|
|
string[] parts = nodeText.Split(new char[] { '\t' }, 2);
|
|
|
|
Font nodeFont = e.Node.NodeFont;
|
|
if (nodeFont == null) nodeFont = ((TreeView)sender).Font;
|
|
|
|
int wd = (int)e.Graphics.MeasureString(parts[parts.Length - 1], nodeFont).Width;
|
|
nodeRect.Width = wd;
|
|
|
|
string pad = " ".PadLeft(actionidmaxdigits+1, '9');
|
|
SizeF tagSize = e.Graphics.MeasureString(pad, nodeFont);
|
|
if (parts.Length == 2)
|
|
nodeRect.Width += (int)tagSize.Width;
|
|
|
|
Brush fgBrush = null;
|
|
if ((e.State & TreeNodeStates.Selected) != 0)
|
|
{
|
|
// fill selected bg
|
|
e.Graphics.FillRectangle(SystemBrushes.Highlight, nodeRect);
|
|
// draw the node text
|
|
fgBrush = SystemBrushes.HighlightText;
|
|
}
|
|
else
|
|
{
|
|
// fill non selected bg (winforms does weird things here)
|
|
// never understood the fact that "Window" color is actually white, but actual window background is counted as "3D element".
|
|
e.Graphics.FillRectangle(SystemBrushes.Window, nodeRect);
|
|
//
|
|
fgBrush = SystemBrushes.WindowText;
|
|
}
|
|
|
|
StringFormat nodeStringFmt = new StringFormat
|
|
{
|
|
FormatFlags = StringFormatFlags.NoWrap,
|
|
Trimming = StringTrimming.None
|
|
};
|
|
|
|
if (parts.Length == 2)
|
|
{
|
|
e.Graphics.DrawString(parts[0], nodeFont, fgBrush, nodeTextRect, nodeStringFmt);
|
|
nodeTextRect.X += (int)tagSize.Width;
|
|
e.Graphics.DrawString(parts[1], nodeFont, fgBrush, nodeTextRect, nodeStringFmt);
|
|
}
|
|
else
|
|
{
|
|
e.Graphics.DrawString(parts[0], nodeFont, fgBrush, nodeTextRect, nodeStringFmt);
|
|
}
|
|
|
|
/*
|
|
// If the node has focus, draw the focus rectangle large, making
|
|
// it large enough to include the text of the node tag, if present.
|
|
if ((e.State & TreeNodeStates.Focused) != 0)
|
|
{
|
|
using (Pen focusPen = SystemPens.In)
|
|
{
|
|
focusPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dot;
|
|
Rectangle focusBounds = nodeRect;
|
|
focusBounds.Size = new Size(focusBounds.Width - 1, focusBounds.Height - 1);
|
|
e.Graphics.DrawRectangle(focusPen, focusBounds);
|
|
}
|
|
}*/
|
|
}
|
|
|
|
// This browses for an action
|
|
// Returns the new action or the same action when cancelled
|
|
public static int BrowseAction(IWin32Window owner, int action) { return BrowseAction(owner, action, false); } //mxd
|
|
public static int BrowseAction(IWin32Window owner, int action, bool addanyaction)
|
|
{
|
|
ActionBrowserForm f = new ActionBrowserForm(action, addanyaction);
|
|
if(f.ShowDialog(owner) == DialogResult.OK) action = f.SelectedAction;
|
|
f.Dispose();
|
|
return action;
|
|
}
|
|
|
|
//mxd
|
|
private void CreateActionCategories(int action)
|
|
{
|
|
actions.BeginUpdate();
|
|
actions.ShowLines = true;
|
|
|
|
// Add "Any action" item?
|
|
if(addanyaction)
|
|
{
|
|
TreeNode aan = actions.Nodes.Add("Any action");
|
|
aan.Tag = new LinedefActionInfo(-1, "Any action", false, false);
|
|
if(action == -1)
|
|
{
|
|
actions.SelectedNode = aan;
|
|
aan.EnsureVisible();
|
|
}
|
|
}
|
|
|
|
foreach(LinedefActionCategory ac in General.Map.Config.ActionCategories)
|
|
{
|
|
// Empty category names will not be created
|
|
// (those actions will go in the root of the tree)
|
|
if(ac.Title.Length > 0)
|
|
{
|
|
// Create category
|
|
TreeNode cn = actions.Nodes.Add(ac.Title);
|
|
foreach(LinedefActionInfo ai in ac.Actions)
|
|
{
|
|
// Create action
|
|
TreeNode n = cn.Nodes.Add((ai.Index > 0) ? string.Format("{0}\t{1}", ai.Index, ai.Title) : ai.Title);
|
|
n.Tag = ai;
|
|
|
|
// Get number of digits in the int. Thanks to https://stackoverflow.com/a/4483960
|
|
// We need this for the correct spacing between the action id and the description
|
|
if (ai.Index > 0)
|
|
{
|
|
int numdigits = (int)Math.Floor(Math.Log10(ai.Index) + 1);
|
|
if (actionidmaxdigits < numdigits)
|
|
actionidmaxdigits = numdigits;
|
|
}
|
|
|
|
// This is the given action?
|
|
if (ai.Index == action)
|
|
{
|
|
// Select this and expand the category
|
|
cn.Expand();
|
|
actions.SelectedNode = n;
|
|
n.EnsureVisible();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Put actions in the tree root
|
|
foreach(LinedefActionInfo ai in ac.Actions)
|
|
{
|
|
// Create action
|
|
TreeNode n = actions.Nodes.Add((ai.Index > 0) ? string.Format("{0}\t{1}", ai.Index, ai.Title) : ai.Title);
|
|
n.Tag = ai;
|
|
}
|
|
}
|
|
}
|
|
actions.EndUpdate();
|
|
}
|
|
|
|
//mxd
|
|
private void FilterActions(string text)
|
|
{
|
|
List<TreeNode> filterednodes = new List<TreeNode>();
|
|
HashSet<string> added = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
|
|
|
// First add nodes, which titles start with given text
|
|
foreach(TreeNode n in allNodes)
|
|
{
|
|
foreach(TreeNode cn in n.Nodes)
|
|
{
|
|
LinedefActionInfo ai = cn.Tag as LinedefActionInfo;
|
|
if(ai != null && ai.Title.ToUpperInvariant().StartsWith(text))
|
|
{
|
|
filterednodes.Add(cn);
|
|
added.Add(ai.Title);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Then add nodes, which titles contain given text
|
|
foreach(TreeNode n in allNodes)
|
|
{
|
|
foreach(TreeNode cn in n.Nodes)
|
|
{
|
|
LinedefActionInfo ai = cn.Tag as LinedefActionInfo;
|
|
if(ai != null && !added.Contains(ai.Title) && ai.Title.ToUpperInvariant().Contains(text))
|
|
filterednodes.Add(cn);
|
|
}
|
|
}
|
|
|
|
actions.BeginUpdate();
|
|
actions.Nodes.Clear();
|
|
actions.ShowLines = false;
|
|
actions.Nodes.AddRange(filterednodes.ToArray());
|
|
actions.EndUpdate();
|
|
}
|
|
|
|
// OK clicked
|
|
private void apply_Click(object sender, EventArgs e)
|
|
{
|
|
// Presume no result
|
|
selectedaction = 0;
|
|
|
|
// Predefined action?
|
|
if(tabs.SelectedTab == tabactions)
|
|
{
|
|
// Action node selected?
|
|
if(actions.SelectedNode != null && (actions.SelectedNode.Tag is LinedefActionInfo))
|
|
{
|
|
// Our result
|
|
selectedaction = ((LinedefActionInfo)actions.SelectedNode.Tag).Index;
|
|
}
|
|
}
|
|
// Generalized action
|
|
else
|
|
{
|
|
// Category selected?
|
|
if(category.SelectedIndex > -1)
|
|
{
|
|
// Add category bits and go for all options
|
|
GeneralizedCategory sc = category.SelectedItem as GeneralizedCategory;
|
|
selectedaction = sc.Offset;
|
|
for(int i = 0; i < MAX_OPTIONS; i++)
|
|
{
|
|
// Option used?
|
|
if(i < sc.Options.Count)
|
|
{
|
|
// Add selected bits
|
|
if(options[i].SelectedIndex > -1)
|
|
selectedaction += (options[i].SelectedItem as GeneralizedBit).Index;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Done
|
|
this.DialogResult = DialogResult.OK;
|
|
this.Close();
|
|
}
|
|
|
|
// Cancel clicked
|
|
private void cancel_Click(object sender, EventArgs e)
|
|
{
|
|
// Leave
|
|
this.DialogResult = DialogResult.Cancel;
|
|
this.Close();
|
|
}
|
|
|
|
// Generalized category selected
|
|
private void category_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
// Category selected?
|
|
if(category.SelectedIndex > -1)
|
|
{
|
|
// Get the category
|
|
GeneralizedCategory ac = category.SelectedItem as GeneralizedCategory;
|
|
|
|
// Go for all options
|
|
for(int i = 0; i < MAX_OPTIONS; i++)
|
|
{
|
|
// Option used in selected category?
|
|
if(i < ac.Options.Count)
|
|
{
|
|
// Setup controls
|
|
optionlbls[i].Text = ac.Options[i].Name + ":";
|
|
options[i].Items.Clear();
|
|
options[i].Items.AddRange(ac.Options[i].Bits.ToArray());
|
|
|
|
// Show option
|
|
options[i].Visible = true;
|
|
optionlbls[i].Visible = true;
|
|
}
|
|
else
|
|
{
|
|
// Hide option
|
|
options[i].Visible = false;
|
|
optionlbls[i].Visible = false;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Hide all options
|
|
for(int i = 0; i < MAX_OPTIONS; i++)
|
|
{
|
|
options[i].Visible = false;
|
|
optionlbls[i].Visible = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Double clicking on item
|
|
private void actions_DoubleClick(object sender, EventArgs e)
|
|
{
|
|
// Action node selected?
|
|
if((actions.SelectedNode != null) && (actions.SelectedNode.Tag is LinedefActionInfo))
|
|
{
|
|
if(apply.Enabled) apply_Click(this, EventArgs.Empty);
|
|
}
|
|
}
|
|
|
|
//mxd
|
|
private void tbFilter_TextChanged(object sender, EventArgs e)
|
|
{
|
|
if(!string.IsNullOrEmpty(tbFilter.Text.Trim()))
|
|
{
|
|
FilterActions(tbFilter.Text.ToUpperInvariant());
|
|
}
|
|
else
|
|
{
|
|
actions.Nodes.Clear();
|
|
CreateActionCategories(actions.SelectedNode != null ? ((LinedefActionInfo)actions.SelectedNode.Tag).Index : 0);
|
|
}
|
|
}
|
|
|
|
//mxd. Switch focus to actions list?
|
|
private void tbFilter_KeyUp(object sender, KeyEventArgs e)
|
|
{
|
|
if(e.KeyCode == Keys.Down && actions.Nodes.Count > 0)
|
|
{
|
|
actions.SelectedNode = actions.Nodes[0];
|
|
actions.Focus();
|
|
}
|
|
}
|
|
|
|
//mxd
|
|
private void btnClearFilter_Click(object sender, EventArgs e)
|
|
{
|
|
tbFilter.Clear();
|
|
}
|
|
|
|
//mxd
|
|
private void ActionBrowserForm_Shown(object sender, EventArgs e)
|
|
{
|
|
if(tabs.SelectedTab == tabactions) tbFilter.Focus();
|
|
}
|
|
|
|
//mxd
|
|
private void actions_MouseEnter(object sender, EventArgs e)
|
|
{
|
|
actions.Focus();
|
|
}
|
|
|
|
//mxd. Transfer focus to Filter textbox
|
|
private void actions_KeyPress(object sender, KeyPressEventArgs e)
|
|
{
|
|
tbFilter.Focus();
|
|
if(e.KeyChar == '\b') // Any better way to check for Backspace?..
|
|
{
|
|
if(!string.IsNullOrEmpty(tbFilter.Text) && tbFilter.SelectionStart > 0 && tbFilter.SelectionLength == 0)
|
|
{
|
|
int s = tbFilter.SelectionStart - 1;
|
|
tbFilter.Text = tbFilter.Text.Remove(s, 1);
|
|
tbFilter.SelectionStart = s;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
tbFilter.AppendText(e.KeyChar.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
}
|
|
}
|