mirror of
https://git.do.srb2.org/STJr/UltimateZoneBuilder.git
synced 2024-12-16 07:01:08 +00:00
731 lines
24 KiB
C#
Executable file
731 lines
24 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.Globalization;
|
|
using System.Windows.Forms;
|
|
using CodeImp.DoomBuilder.GZBuilder.Data;
|
|
using CodeImp.DoomBuilder.Map;
|
|
using CodeImp.DoomBuilder.Config;
|
|
using CodeImp.DoomBuilder.Types;
|
|
using CodeImp.DoomBuilder.GZBuilder;
|
|
using CodeImp.DoomBuilder.Data;
|
|
|
|
#endregion
|
|
|
|
namespace CodeImp.DoomBuilder.Controls
|
|
{
|
|
internal partial class LinedefInfoPanel : UserControl
|
|
{
|
|
private readonly int hexenformatwidth;
|
|
private readonly int doomformatwidth;
|
|
|
|
// Constructor
|
|
public LinedefInfoPanel()
|
|
{
|
|
// Initialize
|
|
InitializeComponent();
|
|
CodeImp.DoomBuilder.General.ApplyMonoListViewFix(flags);
|
|
|
|
// Hide stuff when in Doom format
|
|
hexenformatwidth = infopanel.Width;
|
|
doomformatwidth = infopanel.Width - 190;
|
|
|
|
//mxd
|
|
labelTextureFrontTop.BackColor = Color.FromArgb(128, labelTextureFrontTop.BackColor);
|
|
labelTextureFrontMid.BackColor = Color.FromArgb(128, labelTextureFrontMid.BackColor);
|
|
labelTextureFrontBottom.BackColor = Color.FromArgb(128, labelTextureFrontBottom.BackColor);
|
|
|
|
labelTextureBackTop.BackColor = Color.FromArgb(128, labelTextureBackTop.BackColor);
|
|
labelTextureBackMid.BackColor = Color.FromArgb(128, labelTextureBackMid.BackColor);
|
|
labelTextureBackBottom.BackColor = Color.FromArgb(128, labelTextureBackBottom.BackColor);
|
|
}
|
|
|
|
// This shows the info
|
|
public void ShowInfo(Linedef l, Sidedef highlightside)
|
|
{
|
|
string peggedness;
|
|
|
|
// Show/hide stuff depending on format
|
|
if(!General.Map.FormatInterface.HasActionArgs)
|
|
{
|
|
arglbl1.Visible = false;
|
|
arglbl2.Visible = false;
|
|
arglbl3.Visible = false;
|
|
arglbl4.Visible = false;
|
|
arglbl5.Visible = false;
|
|
arg1.Visible = false;
|
|
arg2.Visible = false;
|
|
arg3.Visible = false;
|
|
arg4.Visible = false;
|
|
arg5.Visible = false;
|
|
infopanel.Width = doomformatwidth;
|
|
}
|
|
else
|
|
{
|
|
arglbl1.Visible = true;
|
|
arglbl2.Visible = true;
|
|
arglbl3.Visible = true;
|
|
arglbl4.Visible = true;
|
|
arglbl5.Visible = true;
|
|
arg1.Visible = true;
|
|
arg2.Visible = true;
|
|
arg3.Visible = true;
|
|
arg4.Visible = true;
|
|
arg5.Visible = true;
|
|
infopanel.Width = hexenformatwidth;
|
|
}
|
|
|
|
//mxd. Hide activation or tag and rearrange labels
|
|
if(!General.Map.FormatInterface.HasBuiltInActivations && General.Map.FormatInterface.HasNumericLinedefActivations) //Hexen map format?
|
|
{
|
|
activation.Visible = true;
|
|
activationlabel.Text = "Activation:";
|
|
activationlabel.Visible = true;
|
|
taglabel.Visible = false;
|
|
tag.Visible = false;
|
|
|
|
//set activation
|
|
foreach(LinedefActivateInfo ai in General.Map.Config.LinedefActivates)
|
|
{
|
|
if(l.Activate == ai.Index)
|
|
{
|
|
activation.Text = ai.Title;
|
|
break;
|
|
}
|
|
}
|
|
|
|
activation.Enabled = (l.Activate != 0 || l.Action != 0); //mxd
|
|
activationlabel.Enabled = (l.Activate != 0 || l.Action != 0); //mxd
|
|
}
|
|
else
|
|
{
|
|
if(General.Map.UDMF)
|
|
{
|
|
// Hijack activation labels to show lock numer...
|
|
activationlabel.Text = "Lock:";
|
|
activationlabel.Visible = true;
|
|
activation.Visible = true;
|
|
|
|
int locknum = l.Fields.GetValue("locknumber", 0);
|
|
if(locknum != 0)
|
|
{
|
|
activationlabel.Enabled = true;
|
|
activation.Enabled = true;
|
|
|
|
if(General.Map.Config.Enums.ContainsKey("keys"))
|
|
{
|
|
foreach(EnumItem item in General.Map.Config.Enums["keys"])
|
|
{
|
|
if(item.GetIntValue() == locknum)
|
|
{
|
|
activation.Text = locknum + " - " + item.Title;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
activation.Text = locknum.ToString();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
activationlabel.Enabled = false;
|
|
activation.Enabled = false;
|
|
activation.Text = "None";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Should be Doom map format
|
|
activationlabel.Visible = false;
|
|
activation.Visible = false;
|
|
}
|
|
|
|
taglabel.Visible = true;
|
|
tag.Visible = true;
|
|
|
|
//mxd. Set tag(s)
|
|
if(l.Tags.Count > 1)
|
|
{
|
|
string[] tags = new string[l.Tags.Count];
|
|
for(int i = 0; i < l.Tags.Count; i++) tags[i] = l.Tags[i].ToString();
|
|
tag.Text = string.Join(", ", tags);
|
|
tag.Enabled = true;
|
|
taglabel.Enabled = true;
|
|
taglabel.Text = "Tags:";
|
|
}
|
|
else
|
|
{
|
|
tag.Text = l.Tag + (General.Map.Options.TagLabels.ContainsKey(l.Tag) ? " - " + General.Map.Options.TagLabels[l.Tag] : string.Empty);
|
|
tag.Enabled = (l.Tag != 0);
|
|
taglabel.Enabled = (l.Tag != 0);
|
|
taglabel.Text = "Tag:";
|
|
}
|
|
}
|
|
|
|
// Get line action information
|
|
LinedefActionInfo act = General.Map.Config.GetLinedefActionInfo(l.Action);
|
|
|
|
// Determine peggedness
|
|
bool upperunpegged = l.IsFlagSet(General.Map.Config.UpperUnpeggedFlag);
|
|
bool lowerunpegged = l.IsFlagSet(General.Map.Config.LowerUnpeggedFlag);
|
|
if(upperunpegged && lowerunpegged)
|
|
peggedness = "Upper & Lower";
|
|
else if(upperunpegged)
|
|
peggedness = "Upper";
|
|
else if(lowerunpegged)
|
|
peggedness = "Lower";
|
|
else
|
|
peggedness = "None";
|
|
|
|
// Linedef info
|
|
#if DEBUG
|
|
infopanel.Text = " Linedef " + l.Index + " (vert. " + l.Start.Index + " - vert. " + l.End.Index + ") ";
|
|
#else
|
|
infopanel.Text = " Linedef " + l.Index + " ";
|
|
#endif
|
|
action.Text = act.ToString();
|
|
length.Text = l.Length.ToString("0.##");
|
|
angle.Text = l.AngleDeg + "\u00B0";
|
|
unpegged.Text = peggedness;
|
|
unpegged.Enabled = (peggedness != "None"); //mxd
|
|
peglabel.Enabled = (peggedness != "None"); //mxd
|
|
action.Enabled = (act.Index != 0);
|
|
actionlabel.Enabled = (act.Index != 0);
|
|
|
|
//mxd. ACS script argument names
|
|
bool isacsscript = (Array.IndexOf(GZGeneral.ACS_SPECIALS, l.Action) != -1);
|
|
bool isarg0str = (General.Map.UDMF && l.Fields.ContainsKey("arg0str"));
|
|
string arg0str = isarg0str ? l.Fields.GetValue("arg0str", string.Empty) : string.Empty;
|
|
ScriptItem scriptitem = null;
|
|
|
|
//mxd. Set default label colors
|
|
arg1.ForeColor = SystemColors.ControlText;
|
|
arglbl1.ForeColor = SystemColors.ControlText;
|
|
|
|
// Named script?
|
|
if(isacsscript && isarg0str && General.Map.NamedScripts.ContainsKey(arg0str.ToLowerInvariant()))
|
|
{
|
|
scriptitem = General.Map.NamedScripts[arg0str.ToLowerInvariant()];
|
|
}
|
|
// Script number?
|
|
else if(isacsscript && General.Map.NumberedScripts.ContainsKey(l.Args[0]))
|
|
{
|
|
scriptitem = General.Map.NumberedScripts[l.Args[0]];
|
|
arg0str = (scriptitem.HasCustomName ? scriptitem.Name : scriptitem.Index.ToString());
|
|
}
|
|
|
|
// Apply script args?
|
|
Label[] arglabels = { arglbl1, arglbl2, arglbl3, arglbl4, arglbl5 };
|
|
Label[] args = { arg1, arg2, arg3, arg4, arg5 };
|
|
|
|
if(scriptitem != null)
|
|
{
|
|
int first;
|
|
string[] argnames = scriptitem.GetArgumentsDescriptions(l.Action, out first);
|
|
for (int i = 0; i < first; i++)
|
|
{
|
|
arglabels[i].Text = (isarg0str ? act.Args[i].TitleStr : act.Args[i].Title) + ":";
|
|
arglabels[i].Enabled = act.Args[i].Used;
|
|
args[i].Enabled = act.Args[i].Used;
|
|
}
|
|
|
|
for (int i = first; i < argnames.Length; i++)
|
|
{
|
|
if(!string.IsNullOrEmpty(argnames[i]))
|
|
{
|
|
arglabels[i].Text = argnames[i] + ":";
|
|
arglabels[i].Enabled = true;
|
|
args[i].Enabled = true;
|
|
}
|
|
else
|
|
{
|
|
arglabels[i].Text = (isarg0str ? act.Args[i].TitleStr : act.Args[i].Title) + ":";
|
|
arglabels[i].Enabled = act.Args[i].Used;
|
|
args[i].Enabled = act.Args[i].Used;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(int i = 0; i < act.Args.Length; i++)
|
|
{
|
|
arglabels[i].Text = (isarg0str ? act.Args[i].TitleStr : act.Args[i].Title) + ":";
|
|
arglabels[i].Enabled = act.Args[i].Used;
|
|
args[i].Enabled = act.Args[i].Used;
|
|
}
|
|
|
|
// Special cases: unknown script name/index
|
|
if(isacsscript)
|
|
{
|
|
arglbl1.Text = "Unknown script " + (isarg0str ? "name" : "number") + ":";
|
|
arg1.ForeColor = Color.DarkRed;
|
|
arglbl1.ForeColor = Color.DarkRed;
|
|
}
|
|
}
|
|
|
|
//mxd. Set argument value and label
|
|
if(isarg0str) arg1.Text = arg0str;
|
|
else SetArgumentText(act.Args[0], arg1, l.Args[0]);
|
|
SetArgumentText(act.Args[1], arg2, l.Args[1]);
|
|
SetArgumentText(act.Args[2], arg3, l.Args[2]);
|
|
SetArgumentText(act.Args[3], arg4, l.Args[3]);
|
|
SetArgumentText(act.Args[4], arg5, l.Args[4]);
|
|
|
|
// Front side available?
|
|
if(l.Front != null)
|
|
{
|
|
//mxd. Extended info shown?
|
|
bool hasTopFields = false;
|
|
bool hasMiddleFields = false;
|
|
bool hasBottomFields = false;
|
|
|
|
//mxd. Highlight this side?
|
|
bool highlight = (l.Front == highlightside);
|
|
frontpanel.ForeColor = (highlight ? SystemColors.HotTrack : SystemColors.WindowText); //mxd
|
|
|
|
// Show sidedef info
|
|
frontpanel.Visible = true; //mxd
|
|
frontpanel.Text = " Front Sidedef " + l.Front.Index;
|
|
|
|
//mxd
|
|
if(General.Map.UDMF)
|
|
{
|
|
//light
|
|
frontoffsetlabel.Text = "Front light:";
|
|
SetUDMFLight(l.Front, frontoffsetlabel, frontoffset, highlight);
|
|
|
|
//global offset, sector index
|
|
frontpanel.Text += ". Offset " + l.Front.OffsetX + ", " + l.Front.OffsetY + ". Sector " + l.Front.Sector.Index + " ";
|
|
|
|
//sidedef top
|
|
hasTopFields = SetPairedUDMFFieldsLabel(l.Front.Fields, "offsetx_top", "offsety_top", 0.0, frontTopUDMFOffsetLabel, frontTopUDMFOffset, highlight);
|
|
hasTopFields |= SetPairedUDMFFieldsLabel(l.Front.Fields, "scalex_top", "scaley_top", 1.0, frontTopUDMFScaleLabel, frontTopUDMFScale, highlight);
|
|
|
|
//sidedef middle
|
|
hasMiddleFields = SetPairedUDMFFieldsLabel(l.Front.Fields, "offsetx_mid", "offsety_mid", 0.0, frontMidUDMFOffsetLabel, frontMidUDMFOffset, highlight);
|
|
hasMiddleFields |= SetPairedUDMFFieldsLabel(l.Front.Fields, "scalex_mid", "scaley_mid", 1.0, frontMidUDMFScaleLabel, frontMidUDMFScale, highlight);
|
|
|
|
//sidedef bottom
|
|
hasBottomFields = SetPairedUDMFFieldsLabel(l.Front.Fields, "offsetx_bottom", "offsety_bottom", 0.0, frontBottomUDMFOffsetLabel, frontBottomUDMFOffset, highlight);
|
|
hasBottomFields |= SetPairedUDMFFieldsLabel(l.Front.Fields, "scalex_bottom", "scaley_bottom", 1.0, frontBottomUDMFScaleLabel, frontBottomUDMFScale, highlight);
|
|
|
|
//visibility
|
|
frontTopUDMFOffset.Visible = hasTopFields;
|
|
frontTopUDMFOffsetLabel.Visible = hasTopFields;
|
|
frontTopUDMFScale.Visible = hasTopFields;
|
|
frontTopUDMFScaleLabel.Visible = hasTopFields;
|
|
|
|
frontMidUDMFOffset.Visible = hasMiddleFields;
|
|
frontMidUDMFOffsetLabel.Visible = hasMiddleFields;
|
|
frontMidUDMFScale.Visible = hasMiddleFields;
|
|
frontMidUDMFScaleLabel.Visible = hasMiddleFields;
|
|
|
|
frontBottomUDMFOffset.Visible = hasBottomFields;
|
|
frontBottomUDMFOffsetLabel.Visible = hasBottomFields;
|
|
frontBottomUDMFScale.Visible = hasBottomFields;
|
|
frontBottomUDMFScaleLabel.Visible = hasBottomFields;
|
|
}
|
|
else
|
|
{
|
|
frontoffsetlabel.Text = "Front offset:";
|
|
if(l.Front.OffsetX != 0 || l.Front.OffsetY != 0)
|
|
{
|
|
frontoffset.Text = l.Front.OffsetX + ", " + l.Front.OffsetY;
|
|
frontoffsetlabel.Enabled = true;
|
|
frontoffset.Enabled = true;
|
|
|
|
frontoffset.ForeColor = (highlight ? SystemColors.HotTrack : SystemColors.WindowText);
|
|
frontoffsetlabel.ForeColor = frontoffset.ForeColor;
|
|
}
|
|
else
|
|
{
|
|
frontoffset.Text = "--, --";
|
|
frontoffsetlabel.Enabled = false;
|
|
frontoffset.Enabled = false;
|
|
}
|
|
|
|
//mxd. Sector index
|
|
frontpanel.Text += ". Sector " + l.Front.Sector.Index + " ";
|
|
|
|
//visibility
|
|
frontTopUDMFOffsetLabel.Visible = false;
|
|
frontTopUDMFScaleLabel.Visible = false;
|
|
|
|
frontMidUDMFOffsetLabel.Visible = false;
|
|
frontMidUDMFScaleLabel.Visible = false;
|
|
|
|
frontBottomUDMFOffsetLabel.Visible = false;
|
|
frontBottomUDMFScaleLabel.Visible = false;
|
|
}
|
|
|
|
//mxd. Set texture names, update panel sizes
|
|
UpdateTexturePanel(panelFrontTop, l.Front.HighTexture, fronthighname, labelTextureFrontTop,
|
|
Math.Max(frontTopUDMFOffset.Right, frontTopUDMFScale.Right) + 4, fronthightex,
|
|
frontTopUDMFOffsetLabel.Left, hasTopFields, l.Front.HighRequired());
|
|
|
|
UpdateTexturePanel(panelFrontMid, l.Front.MiddleTexture, frontmidname, labelTextureFrontMid,
|
|
Math.Max(frontMidUDMFOffset.Right, frontMidUDMFScale.Right) + 4, frontmidtex,
|
|
frontMidUDMFOffsetLabel.Left, hasMiddleFields, l.Front.MiddleRequired());
|
|
|
|
UpdateTexturePanel(panelFrontLow, l.Front.LowTexture, frontlowname, labelTextureFrontBottom,
|
|
Math.Max(frontBottomUDMFOffset.Right, frontBottomUDMFScale.Right) + 4, frontlowtex,
|
|
frontBottomUDMFOffsetLabel.Left, hasBottomFields, l.Front.LowRequired());
|
|
|
|
//mxd. Resize panel
|
|
flowLayoutPanelFront.Width = panelFrontLow.Right;
|
|
frontpanel.Width = flowLayoutPanelFront.Width + flowLayoutPanelFront.Left * 2 - 4;
|
|
}
|
|
else
|
|
{
|
|
// Show no info
|
|
if(General.Map.UDMF) //mxd
|
|
{
|
|
frontoffsetlabel.Text = "Front light:";
|
|
frontoffset.Text = "--";
|
|
}
|
|
else
|
|
{
|
|
frontoffsetlabel.Text = "Front offset:";
|
|
frontoffset.Text = "--, --";
|
|
}
|
|
|
|
frontoffsetlabel.Enabled = false;
|
|
frontoffset.Enabled = false;
|
|
|
|
fronthightex.BackgroundImage = null;
|
|
frontmidtex.BackgroundImage = null;
|
|
frontlowtex.BackgroundImage = null;
|
|
|
|
frontpanel.Visible = false; //mxd
|
|
}
|
|
|
|
// Back size available?
|
|
if(l.Back != null)
|
|
{
|
|
//mxd. Extended info shown?
|
|
bool hasTopFields = false;
|
|
bool hasMiddleFields = false;
|
|
bool hasBottomFields = false;
|
|
|
|
//mxd. Highlight this side?
|
|
bool highlight = l.Back == highlightside;
|
|
backpanel.ForeColor = (highlight ? SystemColors.HotTrack : SystemColors.WindowText); //mxd
|
|
|
|
// Show sidedef info
|
|
backpanel.Visible = true; //mxd
|
|
backpanel.Text = " Back Sidedef " + l.Back.Index;
|
|
|
|
//mxd
|
|
if(General.Map.UDMF)
|
|
{
|
|
//light
|
|
backoffsetlabel.Text = "Back light:";
|
|
SetUDMFLight(l.Back, backoffsetlabel, backoffset, highlight);
|
|
|
|
//global offset, sector index
|
|
backpanel.Text += ". Offset " + l.Back.OffsetX + ", " + l.Back.OffsetY + ". Sector " + l.Back.Sector.Index + " ";
|
|
|
|
//sidedef top
|
|
hasTopFields = SetPairedUDMFFieldsLabel(l.Back.Fields, "offsetx_top", "offsety_top", 0.0, backTopUDMFOffsetLabel, backTopUDMFOffset, highlight);
|
|
hasTopFields |= SetPairedUDMFFieldsLabel(l.Back.Fields, "scalex_top", "scaley_top", 1.0, backTopUDMFScaleLabel, backTopUDMFScale, highlight);
|
|
|
|
//sidedef middle
|
|
hasMiddleFields = SetPairedUDMFFieldsLabel(l.Back.Fields, "offsetx_mid", "offsety_mid", 0.0, backMidUDMFOffsetLabel, backMidUDMFOffset, highlight);
|
|
hasMiddleFields |= SetPairedUDMFFieldsLabel(l.Back.Fields, "scalex_mid", "scaley_mid", 1.0, backMidUDMFScaleLabel, backMidUDMFScale, highlight);
|
|
|
|
//sidedef bottom
|
|
hasBottomFields = SetPairedUDMFFieldsLabel(l.Back.Fields, "offsetx_bottom", "offsety_bottom", 0.0, backBottomUDMFOffsetLabel, backBottomUDMFOffset, highlight);
|
|
hasBottomFields |= SetPairedUDMFFieldsLabel(l.Back.Fields, "scalex_bottom", "scaley_bottom", 1.0, backBottomUDMFScaleLabel, backBottomUDMFScale, highlight);
|
|
|
|
//visibility
|
|
backTopUDMFOffset.Visible = hasTopFields;
|
|
backTopUDMFOffsetLabel.Visible = hasTopFields;
|
|
backTopUDMFScale.Visible = hasTopFields;
|
|
backTopUDMFScaleLabel.Visible = hasTopFields;
|
|
|
|
backMidUDMFOffset.Visible = hasMiddleFields;
|
|
backMidUDMFOffsetLabel.Visible = hasMiddleFields;
|
|
backMidUDMFScale.Visible = hasMiddleFields;
|
|
backMidUDMFScaleLabel.Visible = hasMiddleFields;
|
|
|
|
backBottomUDMFOffset.Visible = hasBottomFields;
|
|
backBottomUDMFOffsetLabel.Visible = hasBottomFields;
|
|
backBottomUDMFScale.Visible = hasBottomFields;
|
|
backBottomUDMFScaleLabel.Visible = hasBottomFields;
|
|
}
|
|
else
|
|
{
|
|
backoffsetlabel.Text = "Back offset:";
|
|
if(l.Back.OffsetX != 0 || l.Back.OffsetY != 0)
|
|
{
|
|
backoffset.Text = l.Back.OffsetX + ", " + l.Back.OffsetY;
|
|
backoffsetlabel.Enabled = true;
|
|
backoffset.Enabled = true;
|
|
|
|
backoffset.ForeColor = (highlight ? SystemColors.HotTrack : SystemColors.WindowText);
|
|
backoffsetlabel.ForeColor = backoffset.ForeColor;
|
|
}
|
|
else
|
|
{
|
|
backoffset.Text = "--, --";
|
|
backoffsetlabel.Enabled = false;
|
|
backoffset.Enabled = false;
|
|
}
|
|
|
|
// Sector index
|
|
backpanel.Text += ". Sector " + l.Back.Sector.Index + " ";
|
|
}
|
|
|
|
//mxd. Set texture names, update panel sizes
|
|
UpdateTexturePanel(panelBackTop, l.Back.HighTexture, backhighname, labelTextureBackTop,
|
|
Math.Max(backTopUDMFOffset.Right, backTopUDMFScale.Right) + 4, backhightex,
|
|
backTopUDMFOffsetLabel.Left, hasTopFields, l.Back.HighRequired());
|
|
|
|
UpdateTexturePanel(panelBackMid, l.Back.MiddleTexture, backmidname, labelTextureBackMid,
|
|
Math.Max(backMidUDMFOffset.Right, backMidUDMFScale.Right) + 4, backmidtex,
|
|
backMidUDMFOffsetLabel.Left, hasMiddleFields, l.Back.MiddleRequired());
|
|
|
|
UpdateTexturePanel(panelBackLow, l.Back.LowTexture, backlowname, labelTextureBackBottom,
|
|
Math.Max(backBottomUDMFOffset.Right, backBottomUDMFScale.Right) + 4, backlowtex,
|
|
backBottomUDMFOffsetLabel.Left, hasBottomFields, l.Back.LowRequired());
|
|
|
|
//mxd. Resize panel
|
|
flowLayoutPanelBack.Width = panelBackLow.Right;
|
|
backpanel.Width = flowLayoutPanelBack.Width + flowLayoutPanelBack.Left * 2 - 4;
|
|
}
|
|
else
|
|
{
|
|
// Show no info
|
|
if(General.Map.UDMF) //mxd
|
|
{
|
|
backoffsetlabel.Text = "Back light:";
|
|
backoffset.Text = "--";
|
|
}
|
|
else
|
|
{
|
|
backoffsetlabel.Text = "Back offset:";
|
|
backoffset.Text = "--, --";
|
|
}
|
|
|
|
backoffsetlabel.Enabled = false;
|
|
backoffset.Enabled = false;
|
|
|
|
backhightex.BackgroundImage = null;
|
|
backmidtex.BackgroundImage = null;
|
|
backlowtex.BackgroundImage = null;
|
|
|
|
backpanel.Visible = false; //mxd
|
|
}
|
|
|
|
//mxd. Flags and activations
|
|
flags.Items.Clear();
|
|
|
|
// Add activations
|
|
foreach(LinedefActivateInfo ai in General.Map.Config.LinedefActivates)
|
|
{
|
|
if(l.Flags.ContainsKey(ai.Key) && l.Flags[ai.Key])
|
|
flags.Items.Add(new ListViewItem(ai.Title) { Checked = true, ForeColor = SystemColors.HotTrack });
|
|
}
|
|
|
|
// And flags
|
|
foreach(KeyValuePair<string, string> group in General.Map.Config.LinedefFlags)
|
|
{
|
|
if(l.Flags.ContainsKey(group.Key) && l.Flags[group.Key])
|
|
flags.Items.Add(new ListViewItem(group.Value) { Checked = true });
|
|
}
|
|
|
|
// And front flags
|
|
if(l.Front != null)
|
|
{
|
|
foreach(KeyValuePair<string, string> group in General.Map.Config.SidedefFlags)
|
|
{
|
|
if(l.Front.Flags.ContainsKey(group.Key) && l.Front.Flags[group.Key])
|
|
flags.Items.Add(new ListViewItem("Front: " + group.Value) { Checked = true });
|
|
}
|
|
}
|
|
|
|
// And back flags
|
|
if(l.Back != null)
|
|
{
|
|
foreach(KeyValuePair<string, string> group in General.Map.Config.SidedefFlags)
|
|
{
|
|
if(l.Back.Flags.ContainsKey(group.Key) && l.Back.Flags[group.Key])
|
|
flags.Items.Add(new ListViewItem("Back: " + group.Value) { Checked = true });
|
|
}
|
|
}
|
|
|
|
//mxd. Flags panel visibility and size
|
|
flagsPanel.Visible = (flags.Items.Count > 0);
|
|
if(flags.Items.Count > 0)
|
|
{
|
|
Rectangle rect = flags.GetItemRect(0);
|
|
int itemspercolumn = 1;
|
|
|
|
// Check how many items per column we have...
|
|
for(int i = 1; i < flags.Items.Count; i++)
|
|
{
|
|
if(flags.GetItemRect(i).X != rect.X) break;
|
|
itemspercolumn++;
|
|
}
|
|
|
|
flags.Width = rect.Width * (int)Math.Ceiling(flags.Items.Count / (float)itemspercolumn);
|
|
flagsPanel.Width = flags.Width + flags.Left * 2;
|
|
}
|
|
|
|
// Show the whole thing
|
|
this.Show();
|
|
//this.Update(); // ano - don't think this is needed, and is slow
|
|
}
|
|
|
|
private static void UpdateTexturePanel(Panel panel, string texturename, Label texturenamelabel, Label sizelabel, int maxlabelright, Panel image, int sizeref, bool extendedinfoshown, bool required)
|
|
{
|
|
// Set texture name
|
|
texturenamelabel.Text = (texturename.Length > DataManager.CLASIC_IMAGE_NAME_LENGTH ? texturename : texturename.ToUpperInvariant());
|
|
|
|
// And image
|
|
DisplayTextureImage(image, sizelabel, texturename, required);
|
|
|
|
//Reposition texture name label?
|
|
if(texturenamelabel.Width < image.Width + 2)
|
|
texturenamelabel.Location = new Point(image.Location.X + (image.Width - texturenamelabel.Width) / 2, texturenamelabel.Location.Y);
|
|
else
|
|
texturenamelabel.Location = new Point(image.Location.X, texturenamelabel.Location.Y);
|
|
|
|
// Resize panel
|
|
if(!extendedinfoshown)
|
|
panel.Width = Math.Max(texturenamelabel.Right + image.Location.X + 1, sizeref);
|
|
else
|
|
panel.Width = Math.Max(texturenamelabel.Right, maxlabelright) + image.Location.X;
|
|
}
|
|
|
|
//mxd
|
|
private static bool SetPairedUDMFFieldsLabel(UniFields fields, string paramX, string paramY, double defaultvalue, Label namelabel, Label valuelabel, bool highlight)
|
|
{
|
|
double x = UniFields.GetFloat(fields, paramX, defaultvalue);
|
|
double y = UniFields.GetFloat(fields, paramY, defaultvalue);
|
|
|
|
if(fields.ContainsKey(paramX)) x = (double)fields[paramX].Value;
|
|
if(fields.ContainsKey(paramY)) y = (double)fields[paramY].Value;
|
|
|
|
if(x != defaultvalue || y != defaultvalue)
|
|
{
|
|
valuelabel.Text = x.ToString(CultureInfo.InvariantCulture) + ", " + y.ToString(CultureInfo.InvariantCulture);
|
|
valuelabel.Enabled = true;
|
|
namelabel.Enabled = true;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
valuelabel.Text = "--, --";
|
|
valuelabel.Enabled = highlight;
|
|
namelabel.Enabled = highlight;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//mxd
|
|
private static void SetUDMFLight(Sidedef sd, Label label, Label value, bool highlight)
|
|
{
|
|
if(sd.Fields.ContainsKey("light"))
|
|
{
|
|
int light = (int)sd.Fields["light"].Value;
|
|
|
|
if(sd.Fields.GetValue("lightabsolute", false))
|
|
value.Text = light + " (abs.)";
|
|
else
|
|
value.Text = light + " (" + Math.Min(255, Math.Max(0, (light + sd.Sector.Brightness))) + ")";
|
|
|
|
value.Enabled = true;
|
|
label.Enabled = true;
|
|
}
|
|
else
|
|
{
|
|
value.Text = "-- (" + sd.Sector.Brightness + ")";
|
|
label.Enabled = highlight;
|
|
value.Enabled = highlight;
|
|
}
|
|
|
|
label.ForeColor = (highlight ? SystemColors.HotTrack : SystemColors.WindowText);
|
|
value.ForeColor = label.ForeColor;
|
|
}
|
|
|
|
//mxd
|
|
private static void SetArgumentText(ArgumentInfo info, Label label, int value)
|
|
{
|
|
TypeHandler th = General.Types.GetArgumentHandler(info);
|
|
th.SetValue(value);
|
|
label.Text = th.GetStringValue();
|
|
}
|
|
|
|
// When visible changed
|
|
protected override void OnVisibleChanged(EventArgs e)
|
|
{
|
|
// Hiding panels
|
|
if(!this.Visible)
|
|
{
|
|
fronthightex.BackgroundImage = null;
|
|
frontmidtex.BackgroundImage = null;
|
|
frontlowtex.BackgroundImage = null;
|
|
backhightex.BackgroundImage = null;
|
|
backmidtex.BackgroundImage = null;
|
|
backlowtex.BackgroundImage = null;
|
|
}
|
|
|
|
// Call base
|
|
base.OnVisibleChanged(e);
|
|
}
|
|
|
|
// This shows a sidedef texture in a panel
|
|
private static void DisplayTextureImage(Panel panel, Label sizelabel, string name, bool required)
|
|
{
|
|
// Check if name is a "none" texture
|
|
if((name.Length < 1) || (name == "-"))
|
|
{
|
|
sizelabel.Visible = false; //mxd
|
|
|
|
// Determine image to show
|
|
if(required)
|
|
General.DisplayZoomedImage(panel, Properties.Resources.MissingTexture);
|
|
else
|
|
panel.BackgroundImage = null;
|
|
}
|
|
else
|
|
{
|
|
//mxd
|
|
ImageData texture = General.Map.Data.GetTextureImage(name);
|
|
if(General.Settings.ShowTextureSizes && texture.ImageState == ImageLoadState.Ready && !(texture is UnknownImage))
|
|
{
|
|
sizelabel.Visible = true;
|
|
sizelabel.Text = Math.Abs(texture.ScaledWidth) + "x" + Math.Abs(texture.ScaledHeight);
|
|
}
|
|
else
|
|
{
|
|
sizelabel.Visible = false;
|
|
}
|
|
|
|
// Set the image
|
|
General.DisplayZoomedImage(panel, texture.GetPreview());
|
|
}
|
|
}
|
|
}
|
|
}
|